steel_worldgen/generated/vanilla_density_functions/

overworld.rs

use steel_registry::RegistryExt;
use steel_registry::blocks::block_state_ext::BlockStateExt;
use std::simd::Simd;
use std::simd::Select;
use std::simd::cmp::SimdOrd;
use std::simd::cmp::SimdPartialEq;
use std::simd::cmp::SimdPartialOrd;
use std::simd::num::SimdInt;
use std::simd::num::SimdFloat;
use steel_worldgen::density::spline_eval;
use steel_worldgen::density::RarityValueMapper;
use steel_math::{clamp, map_clamped};
use steel_worldgen::noise::NormalNoise;
use steel_worldgen::random::{PositionalRandom, RandomSplitter};
/// All noise generators needed by this dimension's density functions.
///
/// Created at runtime from a seed via the `create` method.
pub struct OverworldNoises {
    pub n_aquifer_barrier: NormalNoise,
    pub n_aquifer_fluid_level_floodedness: NormalNoise,
    pub n_aquifer_fluid_level_spread: NormalNoise,
    pub n_aquifer_lava: NormalNoise,
    pub n_cave_cheese: NormalNoise,
    pub n_cave_entrance: NormalNoise,
    pub n_cave_layer: NormalNoise,
    pub n_continentalness: NormalNoise,
    pub n_erosion: NormalNoise,
    pub n_jagged: NormalNoise,
    pub n_noodle: NormalNoise,
    pub n_noodle_ridge_a: NormalNoise,
    pub n_noodle_ridge_b: NormalNoise,
    pub n_noodle_thickness: NormalNoise,
    pub n_offset: NormalNoise,
    pub n_ore_gap: NormalNoise,
    pub n_ore_vein_a: NormalNoise,
    pub n_ore_vein_b: NormalNoise,
    pub n_ore_veininess: NormalNoise,
    pub n_pillar: NormalNoise,
    pub n_pillar_rareness: NormalNoise,
    pub n_pillar_thickness: NormalNoise,
    pub n_ridge: NormalNoise,
    pub n_spaghetti_2d: NormalNoise,
    pub n_spaghetti_2d_elevation: NormalNoise,
    pub n_spaghetti_2d_modulator: NormalNoise,
    pub n_spaghetti_2d_thickness: NormalNoise,
    pub n_spaghetti_3d_1: NormalNoise,
    pub n_spaghetti_3d_2: NormalNoise,
    pub n_spaghetti_3d_rarity: NormalNoise,
    pub n_spaghetti_3d_thickness: NormalNoise,
    pub n_spaghetti_roughness: NormalNoise,
    pub n_spaghetti_roughness_modulator: NormalNoise,
    pub n_temperature: NormalNoise,
    pub n_vegetation: NormalNoise,
    pub blended_noise: steel_worldgen::noise::BlendedNoise,
}
impl OverworldNoises {
    /// Create all noise generators from a world seed, positional splitter, and noise parameters.
    pub fn create(
        seed: u64,
        splitter: &RandomSplitter,
        params: &rustc_hash::FxHashMap<String, steel_worldgen::density::NoiseParameters>,
    ) -> Self {
        let _ = seed;
        Self {
            n_aquifer_barrier: {
                let p = params
                    .get("minecraft:aquifer_barrier")
                    .expect(
                        concat!("missing noise params: ", "minecraft:aquifer_barrier"),
                    );
                p.create(splitter, "minecraft:aquifer_barrier")
            },
            n_aquifer_fluid_level_floodedness: {
                let p = params
                    .get("minecraft:aquifer_fluid_level_floodedness")
                    .expect(
                        concat!(
                            "missing noise params: ",
                            "minecraft:aquifer_fluid_level_floodedness"
                        ),
                    );
                p.create(splitter, "minecraft:aquifer_fluid_level_floodedness")
            },
            n_aquifer_fluid_level_spread: {
                let p = params
                    .get("minecraft:aquifer_fluid_level_spread")
                    .expect(
                        concat!(
                            "missing noise params: ",
                            "minecraft:aquifer_fluid_level_spread"
                        ),
                    );
                p.create(splitter, "minecraft:aquifer_fluid_level_spread")
            },
            n_aquifer_lava: {
                let p = params
                    .get("minecraft:aquifer_lava")
                    .expect(concat!("missing noise params: ", "minecraft:aquifer_lava"));
                p.create(splitter, "minecraft:aquifer_lava")
            },
            n_cave_cheese: {
                let p = params
                    .get("minecraft:cave_cheese")
                    .expect(concat!("missing noise params: ", "minecraft:cave_cheese"));
                p.create(splitter, "minecraft:cave_cheese")
            },
            n_cave_entrance: {
                let p = params
                    .get("minecraft:cave_entrance")
                    .expect(
                        concat!("missing noise params: ", "minecraft:cave_entrance"),
                    );
                p.create(splitter, "minecraft:cave_entrance")
            },
            n_cave_layer: {
                let p = params
                    .get("minecraft:cave_layer")
                    .expect(concat!("missing noise params: ", "minecraft:cave_layer"));
                p.create(splitter, "minecraft:cave_layer")
            },
            n_continentalness: {
                let p = params
                    .get("minecraft:continentalness")
                    .expect(
                        concat!("missing noise params: ", "minecraft:continentalness"),
                    );
                p.create(splitter, "minecraft:continentalness")
            },
            n_erosion: {
                let p = params
                    .get("minecraft:erosion")
                    .expect(concat!("missing noise params: ", "minecraft:erosion"));
                p.create(splitter, "minecraft:erosion")
            },
            n_jagged: {
                let p = params
                    .get("minecraft:jagged")
                    .expect(concat!("missing noise params: ", "minecraft:jagged"));
                p.create(splitter, "minecraft:jagged")
            },
            n_noodle: {
                let p = params
                    .get("minecraft:noodle")
                    .expect(concat!("missing noise params: ", "minecraft:noodle"));
                p.create(splitter, "minecraft:noodle")
            },
            n_noodle_ridge_a: {
                let p = params
                    .get("minecraft:noodle_ridge_a")
                    .expect(
                        concat!("missing noise params: ", "minecraft:noodle_ridge_a"),
                    );
                p.create(splitter, "minecraft:noodle_ridge_a")
            },
            n_noodle_ridge_b: {
                let p = params
                    .get("minecraft:noodle_ridge_b")
                    .expect(
                        concat!("missing noise params: ", "minecraft:noodle_ridge_b"),
                    );
                p.create(splitter, "minecraft:noodle_ridge_b")
            },
            n_noodle_thickness: {
                let p = params
                    .get("minecraft:noodle_thickness")
                    .expect(
                        concat!("missing noise params: ", "minecraft:noodle_thickness"),
                    );
                p.create(splitter, "minecraft:noodle_thickness")
            },
            n_offset: {
                let p = params
                    .get("minecraft:offset")
                    .expect(concat!("missing noise params: ", "minecraft:offset"));
                p.create(splitter, "minecraft:offset")
            },
            n_ore_gap: {
                let p = params
                    .get("minecraft:ore_gap")
                    .expect(concat!("missing noise params: ", "minecraft:ore_gap"));
                p.create(splitter, "minecraft:ore_gap")
            },
            n_ore_vein_a: {
                let p = params
                    .get("minecraft:ore_vein_a")
                    .expect(concat!("missing noise params: ", "minecraft:ore_vein_a"));
                p.create(splitter, "minecraft:ore_vein_a")
            },
            n_ore_vein_b: {
                let p = params
                    .get("minecraft:ore_vein_b")
                    .expect(concat!("missing noise params: ", "minecraft:ore_vein_b"));
                p.create(splitter, "minecraft:ore_vein_b")
            },
            n_ore_veininess: {
                let p = params
                    .get("minecraft:ore_veininess")
                    .expect(
                        concat!("missing noise params: ", "minecraft:ore_veininess"),
                    );
                p.create(splitter, "minecraft:ore_veininess")
            },
            n_pillar: {
                let p = params
                    .get("minecraft:pillar")
                    .expect(concat!("missing noise params: ", "minecraft:pillar"));
                p.create(splitter, "minecraft:pillar")
            },
            n_pillar_rareness: {
                let p = params
                    .get("minecraft:pillar_rareness")
                    .expect(
                        concat!("missing noise params: ", "minecraft:pillar_rareness"),
                    );
                p.create(splitter, "minecraft:pillar_rareness")
            },
            n_pillar_thickness: {
                let p = params
                    .get("minecraft:pillar_thickness")
                    .expect(
                        concat!("missing noise params: ", "minecraft:pillar_thickness"),
                    );
                p.create(splitter, "minecraft:pillar_thickness")
            },
            n_ridge: {
                let p = params
                    .get("minecraft:ridge")
                    .expect(concat!("missing noise params: ", "minecraft:ridge"));
                p.create(splitter, "minecraft:ridge")
            },
            n_spaghetti_2d: {
                let p = params
                    .get("minecraft:spaghetti_2d")
                    .expect(concat!("missing noise params: ", "minecraft:spaghetti_2d"));
                p.create(splitter, "minecraft:spaghetti_2d")
            },
            n_spaghetti_2d_elevation: {
                let p = params
                    .get("minecraft:spaghetti_2d_elevation")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_2d_elevation"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_2d_elevation")
            },
            n_spaghetti_2d_modulator: {
                let p = params
                    .get("minecraft:spaghetti_2d_modulator")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_2d_modulator"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_2d_modulator")
            },
            n_spaghetti_2d_thickness: {
                let p = params
                    .get("minecraft:spaghetti_2d_thickness")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_2d_thickness"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_2d_thickness")
            },
            n_spaghetti_3d_1: {
                let p = params
                    .get("minecraft:spaghetti_3d_1")
                    .expect(
                        concat!("missing noise params: ", "minecraft:spaghetti_3d_1"),
                    );
                p.create(splitter, "minecraft:spaghetti_3d_1")
            },
            n_spaghetti_3d_2: {
                let p = params
                    .get("minecraft:spaghetti_3d_2")
                    .expect(
                        concat!("missing noise params: ", "minecraft:spaghetti_3d_2"),
                    );
                p.create(splitter, "minecraft:spaghetti_3d_2")
            },
            n_spaghetti_3d_rarity: {
                let p = params
                    .get("minecraft:spaghetti_3d_rarity")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_3d_rarity"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_3d_rarity")
            },
            n_spaghetti_3d_thickness: {
                let p = params
                    .get("minecraft:spaghetti_3d_thickness")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_3d_thickness"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_3d_thickness")
            },
            n_spaghetti_roughness: {
                let p = params
                    .get("minecraft:spaghetti_roughness")
                    .expect(
                        concat!(
                            "missing noise params: ", "minecraft:spaghetti_roughness"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_roughness")
            },
            n_spaghetti_roughness_modulator: {
                let p = params
                    .get("minecraft:spaghetti_roughness_modulator")
                    .expect(
                        concat!(
                            "missing noise params: ",
                            "minecraft:spaghetti_roughness_modulator"
                        ),
                    );
                p.create(splitter, "minecraft:spaghetti_roughness_modulator")
            },
            n_temperature: {
                let p = params
                    .get("minecraft:temperature")
                    .expect(concat!("missing noise params: ", "minecraft:temperature"));
                p.create(splitter, "minecraft:temperature")
            },
            n_vegetation: {
                let p = params
                    .get("minecraft:vegetation")
                    .expect(concat!("missing noise params: ", "minecraft:vegetation"));
                p.create(splitter, "minecraft:vegetation")
            },
            blended_noise: {
                use steel_worldgen::random::PositionalRandom;
                use steel_worldgen::random::name_hash::NameHash;
                const TERRAIN_HASH: NameHash = NameHash::new("minecraft:terrain");
                let mut terrain_random = splitter.with_hash_of(&TERRAIN_HASH);
                steel_worldgen::noise::BlendedNoise::new(
                    &mut terrain_random,
                    0.25,
                    0.125,
                    80.0,
                    160.0,
                    8.0,
                )
            },
        }
    }
}
/// Column-level cache for xz-only density function results.
///
/// Supports two modes:
/// - **Grid mode** (`init_grid()` called): Pre-computes a 2D grid of all
///   in-chunk quart positions. `ensure()` does O(1) grid lookups for exact
///   grid points and evaluates other positions on the fly.
/// - **No-grid mode** (default): Single-entry lazy cache that recomputes
///   when the exact coordinates change.
#[derive(Clone)]
pub struct OverworldColumnCache {
    /// Raw x block coordinate (for non-flat router functions).
    pub x: i32,
    /// Raw z block coordinate (for non-flat router functions).
    pub z: i32,
    /// X coordinate used to evaluate the cached values.
    qx: i32,
    /// Z coordinate used to evaluate the cached values.
    qz: i32,
    valid: bool,
    grid_first_quart_x: i32,
    grid_first_quart_z: i32,
    has_grid: bool,
    pub df_shift_x: f32,
    pub df_shift_z: f32,
    pub df_overworld__continents: f32,
    pub df_overworld__erosion: f32,
    pub df_overworld__ridges: f32,
    pub df_overworld__ridges_folded: f32,
    pub df_overworld__offset: f32,
    pub df_overworld__factor: f32,
    pub df_overworld__jaggedness: f32,
    pub df_overworld__preliminary_surface_level: f32,
    pub df_overworld__temperature: f32,
    pub df_overworld__vegetation: f32,
    pub router_continentalness: f32,
    pub router_erosion: f32,
    pub router_preliminary_surface_level: f32,
    pub router_ridges: f32,
    pub router_temperature: f32,
    pub router_vegetation: f32,
    pub inline_noise_0: f32,
    pub inline_noise_1: f32,
    grid_df_shift_x: [f32; 25],
    grid_df_shift_z: [f32; 25],
    grid_df_overworld__continents: [f32; 25],
    grid_df_overworld__erosion: [f32; 25],
    grid_df_overworld__ridges: [f32; 25],
    grid_df_overworld__ridges_folded: [f32; 25],
    grid_df_overworld__offset: [f32; 25],
    grid_df_overworld__factor: [f32; 25],
    grid_df_overworld__jaggedness: [f32; 25],
    grid_df_overworld__preliminary_surface_level: [f32; 25],
    grid_df_overworld__temperature: [f32; 25],
    grid_df_overworld__vegetation: [f32; 25],
    grid_router_continentalness: [f32; 25],
    grid_router_erosion: [f32; 25],
    grid_router_preliminary_surface_level: [f32; 25],
    grid_router_ridges: [f32; 25],
    grid_router_temperature: [f32; 25],
    grid_router_vegetation: [f32; 25],
    grid_inline_noise_0: [f32; 25],
    grid_inline_noise_1: [f32; 25],
}
impl OverworldColumnCache {
    /// Grid side length (quart positions per axis).
    const GRID_SIDE: i32 = 5;
    /// Create a new column cache without a pre-computed grid.
    #[must_use]
    pub fn new() -> Self {
        Self {
            x: 0,
            z: 0,
            qx: i32::MIN,
            qz: i32::MIN,
            valid: false,
            grid_first_quart_x: 0,
            grid_first_quart_z: 0,
            has_grid: false,
            df_shift_x: 0.0,
            df_shift_z: 0.0,
            df_overworld__continents: 0.0,
            df_overworld__erosion: 0.0,
            df_overworld__ridges: 0.0,
            df_overworld__ridges_folded: 0.0,
            df_overworld__offset: 0.0,
            df_overworld__factor: 0.0,
            df_overworld__jaggedness: 0.0,
            df_overworld__preliminary_surface_level: 0.0,
            df_overworld__temperature: 0.0,
            df_overworld__vegetation: 0.0,
            router_continentalness: 0.0,
            router_erosion: 0.0,
            router_preliminary_surface_level: 0.0,
            router_ridges: 0.0,
            router_temperature: 0.0,
            router_vegetation: 0.0,
            inline_noise_0: 0.0,
            inline_noise_1: 0.0,
            grid_df_shift_x: [0.0; 25],
            grid_df_shift_z: [0.0; 25],
            grid_df_overworld__continents: [0.0; 25],
            grid_df_overworld__erosion: [0.0; 25],
            grid_df_overworld__ridges: [0.0; 25],
            grid_df_overworld__ridges_folded: [0.0; 25],
            grid_df_overworld__offset: [0.0; 25],
            grid_df_overworld__factor: [0.0; 25],
            grid_df_overworld__jaggedness: [0.0; 25],
            grid_df_overworld__preliminary_surface_level: [0.0; 25],
            grid_df_overworld__temperature: [0.0; 25],
            grid_df_overworld__vegetation: [0.0; 25],
            grid_router_continentalness: [0.0; 25],
            grid_router_erosion: [0.0; 25],
            grid_router_preliminary_surface_level: [0.0; 25],
            grid_router_ridges: [0.0; 25],
            grid_router_temperature: [0.0; 25],
            grid_router_vegetation: [0.0; 25],
            grid_inline_noise_0: [0.0; 25],
            grid_inline_noise_1: [0.0; 25],
        }
    }
    /// Pre-compute flat-cached values for all quart positions in a chunk.
    ///
    /// After this call, `ensure()` for matching grid points copies from
    /// the grid (O(1)). Other positions are evaluated at their exact
    /// coordinates.
    pub fn init_grid(
        &mut self,
        chunk_block_x: i32,
        chunk_block_z: i32,
        noises: &OverworldNoises,
    ) {
        self.grid_first_quart_x = chunk_block_x >> 2;
        self.grid_first_quart_z = chunk_block_z >> 2;
        self.has_grid = true;
        self.valid = false;
        for rel_z in 0..Self::GRID_SIDE {
            for rel_x in 0..Self::GRID_SIDE {
                let x = ((self.grid_first_quart_x + rel_x) << 2) as f64;
                let z = ((self.grid_first_quart_z + rel_z) << 2) as f64;
                let idx = (rel_z * Self::GRID_SIDE + rel_x) as usize;
                let val = compute_shift_x(noises, &*self, x, z);
                self.df_shift_x = val;
                let val = compute_shift_z(noises, &*self, x, z);
                self.df_shift_z = val;
                let val = compute_overworld__continents(noises, &*self, x, z);
                self.df_overworld__continents = val;
                let val = compute_overworld__erosion(noises, &*self, x, z);
                self.df_overworld__erosion = val;
                let val = compute_overworld__ridges(noises, &*self, x, z);
                self.df_overworld__ridges = val;
                let val = compute_overworld__ridges_folded(noises, &*self, x, z);
                self.df_overworld__ridges_folded = val;
                let val = compute_overworld__offset(noises, &*self, x, z);
                self.df_overworld__offset = val;
                let val = compute_overworld__factor(noises, &*self, x, z);
                self.df_overworld__factor = val;
                let val = compute_overworld__jaggedness(noises, &*self, x, z);
                self.df_overworld__jaggedness = val;
                let val = compute_overworld__preliminary_surface_level(
                    noises,
                    &*self,
                    x,
                    z,
                );
                self.df_overworld__preliminary_surface_level = val;
                let val = compute_overworld__temperature(noises, &*self, x, z);
                self.df_overworld__temperature = val;
                let val = compute_overworld__vegetation(noises, &*self, x, z);
                self.df_overworld__vegetation = val;
                self.grid_df_shift_x[idx] = self.df_shift_x;
                self.grid_df_shift_z[idx] = self.df_shift_z;
                self.grid_df_overworld__continents[idx] = self.df_overworld__continents;
                self.grid_df_overworld__erosion[idx] = self.df_overworld__erosion;
                self.grid_df_overworld__ridges[idx] = self.df_overworld__ridges;
                self.grid_df_overworld__ridges_folded[idx] = self
                    .df_overworld__ridges_folded;
                self.grid_df_overworld__offset[idx] = self.df_overworld__offset;
                self.grid_df_overworld__factor[idx] = self.df_overworld__factor;
                self.grid_df_overworld__jaggedness[idx] = self.df_overworld__jaggedness;
                self.grid_df_overworld__preliminary_surface_level[idx] = self
                    .df_overworld__preliminary_surface_level;
                self.grid_df_overworld__temperature[idx] = self
                    .df_overworld__temperature;
                self.grid_df_overworld__vegetation[idx] = self.df_overworld__vegetation;
                let val = compute_router_continentalness(noises, &*self, x, z);
                self.router_continentalness = val;
                let val = compute_router_erosion(noises, &*self, x, z);
                self.router_erosion = val;
                let val = compute_router_preliminary_surface_level(noises, &*self, x, z);
                self.router_preliminary_surface_level = val;
                let val = compute_router_ridges(noises, &*self, x, z);
                self.router_ridges = val;
                let val = compute_router_temperature(noises, &*self, x, z);
                self.router_temperature = val;
                let val = compute_router_vegetation(noises, &*self, x, z);
                self.router_vegetation = val;
                self.grid_router_continentalness[idx] = self.router_continentalness;
                self.grid_router_erosion[idx] = self.router_erosion;
                self.grid_router_preliminary_surface_level[idx] = self
                    .router_preliminary_surface_level;
                self.grid_router_ridges[idx] = self.router_ridges;
                self.grid_router_temperature[idx] = self.router_temperature;
                self.grid_router_vegetation[idx] = self.router_vegetation;
                self.inline_noise_0 = noises
                    .n_spaghetti_2d_elevation
                    .get_value_xz(x * 1.0, z * 1.0);
                self.inline_noise_1 = noises
                    .n_jagged
                    .get_value_xz(x * 1500.0, z * 1500.0);
                self.grid_inline_noise_0[idx] = self.inline_noise_0;
                self.grid_inline_noise_1[idx] = self.inline_noise_1;
            }
        }
    }
    /// Ensure the cache is populated for the given `(x, z)` block coordinates.
    ///
    /// Grid-aligned in-bounds positions load from the pre-computed grid.
    /// Every other position is evaluated at its exact coordinates.
    pub fn ensure(&mut self, x: i32, z: i32, noises: &OverworldNoises) {
        self.x = x;
        self.z = z;
        let quart_x = x >> 2;
        let quart_z = z >> 2;
        if self.has_grid {
            let rel_x = quart_x - self.grid_first_quart_x;
            let rel_z = quart_z - self.grid_first_quart_z;
            if x & 3 == 0 && z & 3 == 0 && rel_x >= 0 && rel_z >= 0
                && rel_x < Self::GRID_SIDE && rel_z < Self::GRID_SIDE
            {
                let eval_x = quart_x << 2;
                let eval_z = quart_z << 2;
                if self.valid && self.qx == eval_x && self.qz == eval_z {
                    return;
                }
                let idx = (rel_z * Self::GRID_SIDE + rel_x) as usize;
                self.df_shift_x = self.grid_df_shift_x[idx];
                self.df_shift_z = self.grid_df_shift_z[idx];
                self.df_overworld__continents = self.grid_df_overworld__continents[idx];
                self.df_overworld__erosion = self.grid_df_overworld__erosion[idx];
                self.df_overworld__ridges = self.grid_df_overworld__ridges[idx];
                self.df_overworld__ridges_folded = self
                    .grid_df_overworld__ridges_folded[idx];
                self.df_overworld__offset = self.grid_df_overworld__offset[idx];
                self.df_overworld__factor = self.grid_df_overworld__factor[idx];
                self.df_overworld__jaggedness = self.grid_df_overworld__jaggedness[idx];
                self.df_overworld__preliminary_surface_level = self
                    .grid_df_overworld__preliminary_surface_level[idx];
                self.df_overworld__temperature = self
                    .grid_df_overworld__temperature[idx];
                self.df_overworld__vegetation = self.grid_df_overworld__vegetation[idx];
                self.router_continentalness = self.grid_router_continentalness[idx];
                self.router_erosion = self.grid_router_erosion[idx];
                self.router_preliminary_surface_level = self
                    .grid_router_preliminary_surface_level[idx];
                self.router_ridges = self.grid_router_ridges[idx];
                self.router_temperature = self.grid_router_temperature[idx];
                self.router_vegetation = self.grid_router_vegetation[idx];
                self.inline_noise_0 = self.grid_inline_noise_0[idx];
                self.inline_noise_1 = self.grid_inline_noise_1[idx];
                self.qx = eval_x;
                self.qz = eval_z;
                self.valid = true;
                return;
            }
            if self.valid && self.qx == x && self.qz == z {
                return;
            }
            self.qx = x;
            self.qz = z;
            let x = x as f64;
            let z = z as f64;
            let val = compute_shift_x(noises, &*self, x, z);
            self.df_shift_x = val;
            let val = compute_shift_z(noises, &*self, x, z);
            self.df_shift_z = val;
            let val = compute_overworld__continents(noises, &*self, x, z);
            self.df_overworld__continents = val;
            let val = compute_overworld__erosion(noises, &*self, x, z);
            self.df_overworld__erosion = val;
            let val = compute_overworld__ridges(noises, &*self, x, z);
            self.df_overworld__ridges = val;
            let val = compute_overworld__ridges_folded(noises, &*self, x, z);
            self.df_overworld__ridges_folded = val;
            let val = compute_overworld__offset(noises, &*self, x, z);
            self.df_overworld__offset = val;
            let val = compute_overworld__factor(noises, &*self, x, z);
            self.df_overworld__factor = val;
            let val = compute_overworld__jaggedness(noises, &*self, x, z);
            self.df_overworld__jaggedness = val;
            let val = compute_overworld__preliminary_surface_level(noises, &*self, x, z);
            self.df_overworld__preliminary_surface_level = val;
            let val = compute_overworld__temperature(noises, &*self, x, z);
            self.df_overworld__temperature = val;
            let val = compute_overworld__vegetation(noises, &*self, x, z);
            self.df_overworld__vegetation = val;
            let val = compute_router_continentalness(noises, &*self, x, z);
            self.router_continentalness = val;
            let val = compute_router_erosion(noises, &*self, x, z);
            self.router_erosion = val;
            let val = compute_router_preliminary_surface_level(noises, &*self, x, z);
            self.router_preliminary_surface_level = val;
            let val = compute_router_ridges(noises, &*self, x, z);
            self.router_ridges = val;
            let val = compute_router_temperature(noises, &*self, x, z);
            self.router_temperature = val;
            let val = compute_router_vegetation(noises, &*self, x, z);
            self.router_vegetation = val;
            self.inline_noise_0 = noises
                .n_spaghetti_2d_elevation
                .get_value_xz(x * 1.0, z * 1.0);
            self.inline_noise_1 = noises.n_jagged.get_value_xz(x * 1500.0, z * 1500.0);
            self.valid = true;
            return;
        }
        if self.valid && self.qx == x && self.qz == z {
            return;
        }
        self.qx = x;
        self.qz = z;
        let x = x as f64;
        let z = z as f64;
        let val = compute_shift_x(noises, &*self, x, z);
        self.df_shift_x = val;
        let val = compute_shift_z(noises, &*self, x, z);
        self.df_shift_z = val;
        let val = compute_overworld__continents(noises, &*self, x, z);
        self.df_overworld__continents = val;
        let val = compute_overworld__erosion(noises, &*self, x, z);
        self.df_overworld__erosion = val;
        let val = compute_overworld__ridges(noises, &*self, x, z);
        self.df_overworld__ridges = val;
        let val = compute_overworld__ridges_folded(noises, &*self, x, z);
        self.df_overworld__ridges_folded = val;
        let val = compute_overworld__offset(noises, &*self, x, z);
        self.df_overworld__offset = val;
        let val = compute_overworld__factor(noises, &*self, x, z);
        self.df_overworld__factor = val;
        let val = compute_overworld__jaggedness(noises, &*self, x, z);
        self.df_overworld__jaggedness = val;
        let val = compute_overworld__preliminary_surface_level(noises, &*self, x, z);
        self.df_overworld__preliminary_surface_level = val;
        let val = compute_overworld__temperature(noises, &*self, x, z);
        self.df_overworld__temperature = val;
        let val = compute_overworld__vegetation(noises, &*self, x, z);
        self.df_overworld__vegetation = val;
        let val = compute_router_continentalness(noises, &*self, x, z);
        self.router_continentalness = val;
        let val = compute_router_erosion(noises, &*self, x, z);
        self.router_erosion = val;
        let val = compute_router_preliminary_surface_level(noises, &*self, x, z);
        self.router_preliminary_surface_level = val;
        let val = compute_router_ridges(noises, &*self, x, z);
        self.router_ridges = val;
        let val = compute_router_temperature(noises, &*self, x, z);
        self.router_temperature = val;
        let val = compute_router_vegetation(noises, &*self, x, z);
        self.router_vegetation = val;
        self.inline_noise_0 = noises
            .n_spaghetti_2d_elevation
            .get_value_xz(x * 1.0, z * 1.0);
        self.inline_noise_1 = noises.n_jagged.get_value_xz(x * 1500.0, z * 1500.0);
        self.valid = true;
    }
}
///`minecraft:overworld/base_3d_noise`
#[inline]
fn compute_overworld__base_3d_noise(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (noises.blended_noise.compute(x, y, z) as f32) as f32
}
///`minecraft:overworld/caves/spaghetti_roughness_function`
#[inline]
fn compute_overworld__caves__spaghetti_roughness_function(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ((((((((((noises
        .n_spaghetti_roughness_modulator
        .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32) * ((-0.05) as f32))) as f32)
        + ((-0.05) as f32))) as f32)
        * (((((((noises.n_spaghetti_roughness.get_value(x * 1.0, y * 1.0, z * 1.0))
            as f32)
            .abs()) as f32) + ((-0.4) as f32))) as f32))) as f32
}
///`minecraft:overworld/caves/entrances`
#[inline]
fn compute_overworld__caves__entrances(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __sc_a = (((((((noises
            .n_cave_entrance
            .get_value(x * 0.75, y * 0.5, z * 0.75)) as f32) + ((0.37) as f32))) as f32)
            + (({
                let __coordinate = (y as i32).clamp(-10, 30) - -10;
                0.3 + __coordinate as f32 * ((0.0 - 0.3) / (30 - -10) as f32)
            }) as f32))) as f32;
        let __sc_b = ((((compute_overworld__caves__spaghetti_roughness_function(
            noises,
            cache,
            x,
            y,
            z,
        )) as f32)
            + ((((((({
                let __cse_0 = (noises
                    .n_spaghetti_3d_rarity
                    .get_value(x * 2.0, y * 1.0, z * 2.0)) as f32;
                {
                    let __sc_a = ((({
                        let __branch_input_1 = (__cse_0) as f32;
                        if __branch_input_1 < -0.5 {
                            ((((noises
                                .n_spaghetti_3d_1
                                .get_value(
                                    x * 1.3333333333333333,
                                    y * 1.3333333333333333,
                                    z * 1.3333333333333333,
                                )) as f32) * ((0.75) as f32))) as f32
                        } else {
                            if __branch_input_1 < 0.0 {
                                ((((noises
                                    .n_spaghetti_3d_1
                                    .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
                                    * ((1.0) as f32))) as f32
                            } else {
                                if __branch_input_1 < 0.5 {
                                    ((((noises
                                        .n_spaghetti_3d_1
                                        .get_value(
                                            x * 0.6666666666666666,
                                            y * 0.6666666666666666,
                                            z * 0.6666666666666666,
                                        )) as f32) * ((1.5) as f32))) as f32
                                } else {
                                    ((((noises
                                        .n_spaghetti_3d_1
                                        .get_value(x * 0.5, y * 0.5, z * 0.5)) as f32)
                                        * ((2.0) as f32))) as f32
                                }
                            }
                        }
                    }) as f32)
                        .abs()) as f32;
                    let __sc_b = ((({
                        let __branch_input_2 = (__cse_0) as f32;
                        if __branch_input_2 < -0.5 {
                            ((((noises
                                .n_spaghetti_3d_2
                                .get_value(
                                    x * 1.3333333333333333,
                                    y * 1.3333333333333333,
                                    z * 1.3333333333333333,
                                )) as f32) * ((0.75) as f32))) as f32
                        } else {
                            if __branch_input_2 < 0.0 {
                                ((((noises
                                    .n_spaghetti_3d_2
                                    .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
                                    * ((1.0) as f32))) as f32
                            } else {
                                if __branch_input_2 < 0.5 {
                                    ((((noises
                                        .n_spaghetti_3d_2
                                        .get_value(
                                            x * 0.6666666666666666,
                                            y * 0.6666666666666666,
                                            z * 0.6666666666666666,
                                        )) as f32) * ((1.5) as f32))) as f32
                                } else {
                                    ((((noises
                                        .n_spaghetti_3d_2
                                        .get_value(x * 0.5, y * 0.5, z * 0.5)) as f32)
                                        * ((2.0) as f32))) as f32
                                }
                            }
                        }
                    }) as f32)
                        .abs()) as f32;
                    if __sc_a > __sc_b { __sc_a } else { __sc_b }
                }
            }) as f32)
                + ((((((((noises
                    .n_spaghetti_3d_thickness
                    .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
                    * ((-0.011500001) as f32))) as f32) + ((-0.0765) as f32))) as f32)))
                as f32)
                .clamp(-1.0, 1.0)) as f32))) as f32;
        if __sc_a < __sc_b { __sc_a } else { __sc_b }
    }) as f32
}
///`minecraft:y`
#[inline]
fn compute_y(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __coordinate = (y as i32).clamp(-4064, 4062) - -4064;
        -4064.0 + __coordinate as f32 * ((4062.0 - -4064.0) / (4062 - -4064) as f32)
    }) as f32
}
///`minecraft:overworld/caves/noodle`
#[inline]
fn compute_overworld__caves__noodle(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __branch_input_4 = (({
            let __branch_input_3 = (compute_y(noises, cache, x, y, z)) as f32;
            if __branch_input_3 >= -60.0 && __branch_input_3 < 321.0 {
                (noises.n_noodle.get_value(x * 1.0, y * 1.0, z * 1.0)) as f32
            } else {
                (-1.0) as f32
            }
        }) as f32) as f32;
        if __branch_input_4 >= -1000000.0 && __branch_input_4 < 0.0 {
            (64.0) as f32
        } else {
            ({
                let __cse_5 = (compute_y(noises, cache, x, y, z)) as f32;
                (((({
                    let __branch_input_6 = __cse_5;
                    if __branch_input_6 >= -60.0 && __branch_input_6 < 321.0 {
                        (((((((noises
                            .n_noodle_thickness
                            .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
                            * ((-0.025) as f32))) as f32) + ((-0.075) as f32))) as f32
                    } else {
                        (0.0) as f32
                    }
                }) as f32) as f32)
                    + ((((({
                        let __sc_a = (((({
                            let __branch_input_7 = __cse_5;
                            if __branch_input_7 >= -60.0 && __branch_input_7 < 321.0 {
                                (noises
                                    .n_noodle_ridge_a
                                    .get_value(
                                        x * 2.6666666666666665,
                                        y * 2.6666666666666665,
                                        z * 2.6666666666666665,
                                    )) as f32
                            } else {
                                (0.0) as f32
                            }
                        }) as f32) as f32)
                            .abs()) as f32;
                        let __sc_b = (((({
                            let __branch_input_8 = __cse_5;
                            if __branch_input_8 >= -60.0 && __branch_input_8 < 321.0 {
                                (noises
                                    .n_noodle_ridge_b
                                    .get_value(
                                        x * 2.6666666666666665,
                                        y * 2.6666666666666665,
                                        z * 2.6666666666666665,
                                    )) as f32
                            } else {
                                (0.0) as f32
                            }
                        }) as f32) as f32)
                            .abs()) as f32;
                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                    }) as f32) * ((1.5) as f32))) as f32))
            }) as f32
        }
    }) as f32
}
///`minecraft:overworld/caves/pillars`
#[inline]
fn compute_overworld__caves__pillars(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ((((((((((noises.n_pillar.get_value(x * 25.0, y * 0.3, z * 25.0)) as f32)
        * ((2.0) as f32))) as f32)
        + ((((((((noises.n_pillar_rareness.get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
            * ((-1.0) as f32))) as f32) + ((-1.0) as f32))) as f32))) as f32)
        * (({
            let v = (((((((noises
                .n_pillar_thickness
                .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32) * ((0.55) as f32)))
                as f32) + ((0.55) as f32))) as f32;
            v * v * v
        }) as f32))) as f32
}
///`minecraft:overworld/caves/spaghetti_2d_thickness_modulator`
#[inline]
fn compute_overworld__caves__spaghetti_2d_thickness_modulator(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (((((((noises.n_spaghetti_2d_thickness.get_value(x * 2.0, y * 1.0, z * 2.0)) as f32)
        * ((-0.34999996) as f32))) as f32) + ((-0.95) as f32))) as f32
}
///`minecraft:overworld/caves/spaghetti_2d`
#[inline]
fn compute_overworld__caves__spaghetti_2d(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ((({
        let __cse_9 = (compute_overworld__caves__spaghetti_2d_thickness_modulator(
            noises,
            cache,
            x,
            y,
            z,
        )) as f32;
        {
            let __sc_a = (((((({
                let __branch_input_10 = (noises
                    .n_spaghetti_2d_modulator
                    .get_value(x * 2.0, y * 1.0, z * 2.0)) as f32;
                if __branch_input_10 < -0.75 {
                    ((((noises.n_spaghetti_2d.get_value(x * 2.0, y * 2.0, z * 2.0))
                        as f32) * ((0.5) as f32))) as f32
                } else {
                    if __branch_input_10 < -0.5 {
                        ((((noises
                            .n_spaghetti_2d
                            .get_value(
                                x * 1.3333333333333333,
                                y * 1.3333333333333333,
                                z * 1.3333333333333333,
                            )) as f32) * ((0.75) as f32))) as f32
                    } else {
                        if __branch_input_10 < 0.5 {
                            ((((noises
                                .n_spaghetti_2d
                                .get_value(x * 1.0, y * 1.0, z * 1.0)) as f32)
                                * ((1.0) as f32))) as f32
                        } else {
                            if __branch_input_10 < 0.75 {
                                ((((noises
                                    .n_spaghetti_2d
                                    .get_value(x * 0.5, y * 0.5, z * 0.5)) as f32)
                                    * ((2.0) as f32))) as f32
                            } else {
                                ((((noises
                                    .n_spaghetti_2d
                                    .get_value(
                                        x * 0.3333333333333333,
                                        y * 0.3333333333333333,
                                        z * 0.3333333333333333,
                                    )) as f32) * ((3.0) as f32))) as f32
                            }
                        }
                    }
                }
            }) as f32)
                .abs()) as f32) + ((((__cse_9) * ((0.083) as f32))) as f32))) as f32;
            let __sc_b = ({
                let v = ((((((((((((cache.inline_noise_0) * ((8.0) as f32))) as f32)
                    as f32)
                    + (({
                        let __coordinate = (y as i32).clamp(-64, 320) - -64;
                        8.0 + __coordinate as f32 * ((-40.0 - 8.0) / (320 - -64) as f32)
                    }) as f32))) as f32)
                    .abs()) as f32) + (__cse_9))) as f32;
                v * v * v
            }) as f32;
            if __sc_a > __sc_b { __sc_a } else { __sc_b }
        }
    }) as f32)
        .clamp(-1.0, 1.0)) as f32
}
///`minecraft:shift_x`
#[inline]
fn compute_shift_x(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (noises.n_offset.get_value_xz(x * 0.25, z * 0.25) * 4.0) as f32
}
///`minecraft:shift_z`
#[inline]
fn compute_shift_z(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (noises.n_offset.get_value_xy(z * 0.25, x * 0.25) * 4.0) as f32
}
///`minecraft:overworld/continents`
#[inline]
fn compute_overworld__continents(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let dx = (cache.df_shift_x) as f32;
        let dz = (cache.df_shift_z) as f32;
        noises
            .n_continentalness
            .get_value_xz(x * 0.25 + f64::from(dx), z * 0.25 + f64::from(dz))
    }) as f32
}
///`minecraft:overworld/erosion`
#[inline]
fn compute_overworld__erosion(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let dx = (cache.df_shift_x) as f32;
        let dz = (cache.df_shift_z) as f32;
        noises.n_erosion.get_value_xz(x * 0.25 + f64::from(dx), z * 0.25 + f64::from(dz))
    }) as f32
}
///`minecraft:overworld/ridges`
#[inline]
fn compute_overworld__ridges(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let dx = (cache.df_shift_x) as f32;
        let dz = (cache.df_shift_z) as f32;
        noises.n_ridge.get_value_xz(x * 0.25 + f64::from(dx), z * 0.25 + f64::from(dz))
    }) as f32
}
///`minecraft:overworld/ridges_folded`
#[inline]
fn compute_overworld__ridges_folded(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ((((((((((((((cache.df_overworld__ridges) as f32).abs()) as f32)
        + ((-0.6666667) as f32))) as f32)
        .abs()) as f32) + ((-0.33333334) as f32))) as f32) * ((-3.0) as f32))) as f32
}
///`minecraft:overworld/offset`
#[inline]
fn compute_overworld__offset(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __lerp_alpha = (1.0) as f32;
        if __lerp_alpha == 0.0 {
            (0.0) as f32
        } else if __lerp_alpha == 1.0 {
            ((((-0.50375) as f32)
                + (({
                    let __coord = ((cache.df_overworld__continents) as f32) as f32;
                    if __coord < -1.1 {
                        f64::from(0.044 + 0.0 * (__coord - -1.1))
                    } else if __coord < -1.02 {
                        let __y1 = 0.044;
                        let __y2 = -0.2222;
                        let __t = (__coord - -1.1) / (-1.02 - -1.1);
                        let __h = -1.02 - -1.1;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.51 {
                        let __y1 = -0.2222;
                        let __y2 = -0.2222;
                        let __t = (__coord - -1.02) / (-0.51 - -1.02);
                        let __h = -0.51 - -1.02;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.44 {
                        let __y1 = -0.2222;
                        let __y2 = -0.12;
                        let __t = (__coord - -0.51) / (-0.44 - -0.51);
                        let __h = -0.44 - -0.51;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.18 {
                        let __y1 = -0.12;
                        let __y2 = -0.12;
                        let __t = (__coord - -0.44) / (-0.18 - -0.44);
                        let __h = -0.18 - -0.44;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.16 {
                        let __y1 = -0.12;
                        let __y2 = spline_helper_0(noises, cache, x, z);
                        let __t = (__coord - -0.18) / (-0.16 - -0.18);
                        let __h = -0.16 - -0.18;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.15 {
                        let __y1 = spline_helper_0(noises, cache, x, z);
                        let __y2 = spline_helper_8(noises, cache, x, z);
                        let __t = (__coord - -0.16) / (-0.15 - -0.16);
                        let __h = -0.15 - -0.16;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < -0.1 {
                        let __y1 = spline_helper_8(noises, cache, x, z);
                        let __y2 = spline_helper_16(noises, cache, x, z);
                        let __t = (__coord - -0.15) / (-0.1 - -0.15);
                        let __h = -0.1 - -0.15;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < 0.25 {
                        let __y1 = spline_helper_16(noises, cache, x, z);
                        let __y2 = spline_helper_24(noises, cache, x, z);
                        let __t = (__coord - -0.1) / (0.25 - -0.1);
                        let __h = 0.25 - -0.1;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else if __coord < 1.0 {
                        let __y1 = spline_helper_24(noises, cache, x, z);
                        let __y2 = spline_helper_38(noises, cache, x, z);
                        let __t = (__coord - 0.25) / (1.0 - 0.25);
                        let __h = 1.0 - 0.25;
                        let __a = 0.0 * __h - (__y2 - __y1);
                        let __b = -0.0 * __h + (__y2 - __y1);
                        let __lerp_y = __y1 + __t * (__y2 - __y1);
                        let __lerp_ab = __a + __t * (__b - __a);
                        f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                    } else {
                        f64::from(
                            spline_helper_38(noises, cache, x, z) + 0.0 * (__coord - 1.0),
                        )
                    }
                }) as f32))) as f32
        } else {
            let __lerp_first = (0.0) as f32;
            __lerp_first
                + __lerp_alpha
                    * ((((((-0.50375) as f32)
                        + (({
                            let __coord = ((cache.df_overworld__continents) as f32)
                                as f32;
                            if __coord < -1.1 {
                                f64::from(0.044 + 0.0 * (__coord - -1.1))
                            } else if __coord < -1.02 {
                                let __y1 = 0.044;
                                let __y2 = -0.2222;
                                let __t = (__coord - -1.1) / (-1.02 - -1.1);
                                let __h = -1.02 - -1.1;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.51 {
                                let __y1 = -0.2222;
                                let __y2 = -0.2222;
                                let __t = (__coord - -1.02) / (-0.51 - -1.02);
                                let __h = -0.51 - -1.02;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.44 {
                                let __y1 = -0.2222;
                                let __y2 = -0.12;
                                let __t = (__coord - -0.51) / (-0.44 - -0.51);
                                let __h = -0.44 - -0.51;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.18 {
                                let __y1 = -0.12;
                                let __y2 = -0.12;
                                let __t = (__coord - -0.44) / (-0.18 - -0.44);
                                let __h = -0.18 - -0.44;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.16 {
                                let __y1 = -0.12;
                                let __y2 = spline_helper_0(noises, cache, x, z);
                                let __t = (__coord - -0.18) / (-0.16 - -0.18);
                                let __h = -0.16 - -0.18;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.15 {
                                let __y1 = spline_helper_0(noises, cache, x, z);
                                let __y2 = spline_helper_8(noises, cache, x, z);
                                let __t = (__coord - -0.16) / (-0.15 - -0.16);
                                let __h = -0.15 - -0.16;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < -0.1 {
                                let __y1 = spline_helper_8(noises, cache, x, z);
                                let __y2 = spline_helper_16(noises, cache, x, z);
                                let __t = (__coord - -0.15) / (-0.1 - -0.15);
                                let __h = -0.1 - -0.15;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < 0.25 {
                                let __y1 = spline_helper_16(noises, cache, x, z);
                                let __y2 = spline_helper_24(noises, cache, x, z);
                                let __t = (__coord - -0.1) / (0.25 - -0.1);
                                let __h = 0.25 - -0.1;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else if __coord < 1.0 {
                                let __y1 = spline_helper_24(noises, cache, x, z);
                                let __y2 = spline_helper_38(noises, cache, x, z);
                                let __t = (__coord - 0.25) / (1.0 - 0.25);
                                let __h = 1.0 - 0.25;
                                let __a = 0.0 * __h - (__y2 - __y1);
                                let __b = -0.0 * __h + (__y2 - __y1);
                                let __lerp_y = __y1 + __t * (__y2 - __y1);
                                let __lerp_ab = __a + __t * (__b - __a);
                                f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                            } else {
                                f64::from(
                                    spline_helper_38(noises, cache, x, z)
                                        + 0.0 * (__coord - 1.0),
                                )
                            }
                        }) as f32))) as f32) - __lerp_first)
        }
    }) as f32
}
///`minecraft:overworld/depth`
#[inline]
fn compute_overworld__depth(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (((({
        let __coordinate = (y as i32).clamp(-64, 320) - -64;
        1.5 + __coordinate as f32 * ((-1.5 - 1.5) / (320 - -64) as f32)
    }) as f32) + ((cache.df_overworld__offset) as f32))) as f32
}
///`minecraft:overworld/factor`
#[inline]
fn compute_overworld__factor(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __lerp_alpha = (1.0) as f32;
        if __lerp_alpha == 0.0 {
            (10.0) as f32
        } else if __lerp_alpha == 1.0 {
            ({
                let __coord = ((cache.df_overworld__continents) as f32) as f32;
                if __coord < -0.19 {
                    f64::from(3.95 + 0.0 * (__coord - -0.19))
                } else if __coord < -0.15 {
                    let __y1 = 3.95;
                    let __y2 = spline_helper_52(noises, cache, x, z);
                    let __t = (__coord - -0.19) / (-0.15 - -0.19);
                    let __h = -0.15 - -0.19;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else if __coord < -0.1 {
                    let __y1 = spline_helper_52(noises, cache, x, z);
                    let __y2 = spline_helper_63(noises, cache, x, z);
                    let __t = (__coord - -0.15) / (-0.1 - -0.15);
                    let __h = -0.1 - -0.15;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else if __coord < 0.03 {
                    let __y1 = spline_helper_63(noises, cache, x, z);
                    let __y2 = spline_helper_74(noises, cache, x, z);
                    let __t = (__coord - -0.1) / (0.03 - -0.1);
                    let __h = 0.03 - -0.1;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else if __coord < 0.06 {
                    let __y1 = spline_helper_74(noises, cache, x, z);
                    let __y2 = spline_helper_85(noises, cache, x, z);
                    let __t = (__coord - 0.03) / (0.06 - 0.03);
                    let __h = 0.06 - 0.03;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else {
                    f64::from(
                        spline_helper_85(noises, cache, x, z) + 0.0 * (__coord - 0.06),
                    )
                }
            }) as f32
        } else {
            let __lerp_first = (10.0) as f32;
            __lerp_first
                + __lerp_alpha
                    * ((({
                        let __coord = ((cache.df_overworld__continents) as f32) as f32;
                        if __coord < -0.19 {
                            f64::from(3.95 + 0.0 * (__coord - -0.19))
                        } else if __coord < -0.15 {
                            let __y1 = 3.95;
                            let __y2 = spline_helper_52(noises, cache, x, z);
                            let __t = (__coord - -0.19) / (-0.15 - -0.19);
                            let __h = -0.15 - -0.19;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else if __coord < -0.1 {
                            let __y1 = spline_helper_52(noises, cache, x, z);
                            let __y2 = spline_helper_63(noises, cache, x, z);
                            let __t = (__coord - -0.15) / (-0.1 - -0.15);
                            let __h = -0.1 - -0.15;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else if __coord < 0.03 {
                            let __y1 = spline_helper_63(noises, cache, x, z);
                            let __y2 = spline_helper_74(noises, cache, x, z);
                            let __t = (__coord - -0.1) / (0.03 - -0.1);
                            let __h = 0.03 - -0.1;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else if __coord < 0.06 {
                            let __y1 = spline_helper_74(noises, cache, x, z);
                            let __y2 = spline_helper_85(noises, cache, x, z);
                            let __t = (__coord - 0.03) / (0.06 - 0.03);
                            let __h = 0.06 - 0.03;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else {
                            f64::from(
                                spline_helper_85(noises, cache, x, z)
                                    + 0.0 * (__coord - 0.06),
                            )
                        }
                    }) as f32) - __lerp_first)
        }
    }) as f32
}
///`minecraft:overworld/jaggedness`
#[inline]
fn compute_overworld__jaggedness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __lerp_alpha = (1.0) as f32;
        if __lerp_alpha == 0.0 {
            (0.0) as f32
        } else if __lerp_alpha == 1.0 {
            ({
                let __coord = ((cache.df_overworld__continents) as f32) as f32;
                if __coord < -0.11 {
                    f64::from(0.0 + 0.0 * (__coord - -0.11))
                } else if __coord < 0.03 {
                    let __y1 = 0.0;
                    let __y2 = spline_helper_100(noises, cache, x, z);
                    let __t = (__coord - -0.11) / (0.03 - -0.11);
                    let __h = 0.03 - -0.11;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else if __coord < 0.65 {
                    let __y1 = spline_helper_100(noises, cache, x, z);
                    let __y2 = spline_helper_107(noises, cache, x, z);
                    let __t = (__coord - 0.03) / (0.65 - 0.03);
                    let __h = 0.65 - 0.03;
                    let __a = 0.0 * __h - (__y2 - __y1);
                    let __b = -0.0 * __h + (__y2 - __y1);
                    let __lerp_y = __y1 + __t * (__y2 - __y1);
                    let __lerp_ab = __a + __t * (__b - __a);
                    f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                } else {
                    f64::from(
                        spline_helper_107(noises, cache, x, z) + 0.0 * (__coord - 0.65),
                    )
                }
            }) as f32
        } else {
            let __lerp_first = (0.0) as f32;
            __lerp_first
                + __lerp_alpha
                    * ((({
                        let __coord = ((cache.df_overworld__continents) as f32) as f32;
                        if __coord < -0.11 {
                            f64::from(0.0 + 0.0 * (__coord - -0.11))
                        } else if __coord < 0.03 {
                            let __y1 = 0.0;
                            let __y2 = spline_helper_100(noises, cache, x, z);
                            let __t = (__coord - -0.11) / (0.03 - -0.11);
                            let __h = 0.03 - -0.11;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else if __coord < 0.65 {
                            let __y1 = spline_helper_100(noises, cache, x, z);
                            let __y2 = spline_helper_107(noises, cache, x, z);
                            let __t = (__coord - 0.03) / (0.65 - 0.03);
                            let __h = 0.65 - 0.03;
                            let __a = 0.0 * __h - (__y2 - __y1);
                            let __b = -0.0 * __h + (__y2 - __y1);
                            let __lerp_y = __y1 + __t * (__y2 - __y1);
                            let __lerp_ab = __a + __t * (__b - __a);
                            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
                        } else {
                            f64::from(
                                spline_helper_107(noises, cache, x, z)
                                    + 0.0 * (__coord - 0.65),
                            )
                        }
                    }) as f32) - __lerp_first)
        }
    }) as f32
}
///`minecraft:overworld/sloped_cheese`
#[inline]
fn compute_overworld__sloped_cheese(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ((((((({
        let v = (((((((compute_overworld__depth(noises, cache, x, y, z)) as f32)
            + ((((((cache.df_overworld__jaggedness) as f32)
                * (({
                    let v = cache.inline_noise_1;
                    if v > 0.0 { v } else { v * 0.5 }
                }) as f32))) as f32) as f32))) as f32)
            * ((cache.df_overworld__factor) as f32))) as f32;
        if v > 0.0 { v } else { v * 0.25 }
    }) as f32) * ((4.0) as f32))) as f32)
        + ((compute_overworld__base_3d_noise(noises, cache, x, y, z)) as f32))) as f32
}
///`minecraft:overworld/final_density`
#[inline]
fn compute_overworld__final_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (((({
        let __sc_a = ({
            let c = ((((((({
                let __lerp_alpha = ({
                    let __coordinate = (y as i32).clamp(-64, -40) - -64;
                    0.0 + __coordinate as f32 * ((1.0 - 0.0) / (-40 - -64) as f32)
                }) as f32;
                if __lerp_alpha == 0.0 {
                    (0.1171875) as f32
                } else if __lerp_alpha == 1.0 {
                    ({
                        let __lerp_alpha = ({
                            let __coordinate = (y as i32).clamp(240, 256) - 240;
                            1.0
                                + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                        }) as f32;
                        if __lerp_alpha == 0.0 {
                            (-0.078125) as f32
                        } else if __lerp_alpha == 1.0 {
                            ({
                                let __branch_input_11 = (compute_overworld__sloped_cheese(
                                    noises,
                                    cache,
                                    x,
                                    y,
                                    z,
                                )) as f32;
                                let __cse_12 = (compute_overworld__caves__entrances(
                                    noises,
                                    cache,
                                    x,
                                    y,
                                    z,
                                )) as f32;
                                if __branch_input_11 >= -1000000.0
                                    && __branch_input_11 < 1.5625
                                {
                                    ({
                                        let __sc_a = __branch_input_11;
                                        let __sc_b = (((__cse_12) * ((5.0) as f32))) as f32;
                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                } else {
                                    ({
                                        let __sc_a = ({
                                            let __sc_a = ({
                                                let __sc_a = ((((((({
                                                    let v = (noises
                                                        .n_cave_layer
                                                        .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                    v * v
                                                }) as f32) * ((4.0) as f32))) as f32)
                                                    + ((((((((((noises
                                                        .n_cave_cheese
                                                        .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                        as f32) + ((0.27) as f32))) as f32)
                                                        .clamp(-1.0, 1.0)) as f32)
                                                        + (((((((((__branch_input_11) * ((-0.64) as f32))) as f32)
                                                            + ((1.5) as f32))) as f32)
                                                            .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                let __sc_b = __cse_12;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32;
                                            let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32)
                                                + ((compute_overworld__caves__spaghetti_roughness_function(
                                                    noises,
                                                    cache,
                                                    x,
                                                    y,
                                                    z,
                                                )) as f32))) as f32;
                                            if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                        }) as f32;
                                        let __sc_b = ({
                                            let __branch_input_13 = (compute_overworld__caves__pillars(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32;
                                            if __branch_input_13 >= -1000000.0
                                                && __branch_input_13 < 0.03
                                            {
                                                (-1000000.0) as f32
                                            } else {
                                                __branch_input_13
                                            }
                                        }) as f32;
                                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                }
                            }) as f32
                        } else {
                            let __lerp_first = (-0.078125) as f32;
                            __lerp_first
                                + __lerp_alpha
                                    * ((({
                                        let __branch_input_11 = (compute_overworld__sloped_cheese(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32;
                                        let __cse_12 = (compute_overworld__caves__entrances(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32;
                                        if __branch_input_11 >= -1000000.0
                                            && __branch_input_11 < 1.5625
                                        {
                                            ({
                                                let __sc_a = __branch_input_11;
                                                let __sc_b = (((__cse_12) * ((5.0) as f32))) as f32;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        } else {
                                            ({
                                                let __sc_a = ({
                                                    let __sc_a = ({
                                                        let __sc_a = ((((((({
                                                            let v = (noises
                                                                .n_cave_layer
                                                                .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                            v * v
                                                        }) as f32) * ((4.0) as f32))) as f32)
                                                            + ((((((((((noises
                                                                .n_cave_cheese
                                                                .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                                as f32) + ((0.27) as f32))) as f32)
                                                                .clamp(-1.0, 1.0)) as f32)
                                                                + (((((((((__branch_input_11) * ((-0.64) as f32))) as f32)
                                                                    + ((1.5) as f32))) as f32)
                                                                    .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                        let __sc_b = __cse_12;
                                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                    }) as f32;
                                                    let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32)
                                                        + ((compute_overworld__caves__spaghetti_roughness_function(
                                                            noises,
                                                            cache,
                                                            x,
                                                            y,
                                                            z,
                                                        )) as f32))) as f32;
                                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                }) as f32;
                                                let __sc_b = ({
                                                    let __branch_input_13 = (compute_overworld__caves__pillars(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32;
                                                    if __branch_input_13 >= -1000000.0
                                                        && __branch_input_13 < 0.03
                                                    {
                                                        (-1000000.0) as f32
                                                    } else {
                                                        __branch_input_13
                                                    }
                                                }) as f32;
                                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        }
                                    }) as f32) - __lerp_first)
                        }
                    }) as f32
                } else {
                    let __lerp_first = (0.1171875) as f32;
                    __lerp_first
                        + __lerp_alpha
                            * ((({
                                let __lerp_alpha = ({
                                    let __coordinate = (y as i32).clamp(240, 256) - 240;
                                    1.0
                                        + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                                }) as f32;
                                if __lerp_alpha == 0.0 {
                                    (-0.078125) as f32
                                } else if __lerp_alpha == 1.0 {
                                    ({
                                        let __branch_input_11 = (compute_overworld__sloped_cheese(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32;
                                        let __cse_12 = (compute_overworld__caves__entrances(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32;
                                        if __branch_input_11 >= -1000000.0
                                            && __branch_input_11 < 1.5625
                                        {
                                            ({
                                                let __sc_a = __branch_input_11;
                                                let __sc_b = (((__cse_12) * ((5.0) as f32))) as f32;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        } else {
                                            ({
                                                let __sc_a = ({
                                                    let __sc_a = ({
                                                        let __sc_a = ((((((({
                                                            let v = (noises
                                                                .n_cave_layer
                                                                .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                            v * v
                                                        }) as f32) * ((4.0) as f32))) as f32)
                                                            + ((((((((((noises
                                                                .n_cave_cheese
                                                                .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                                as f32) + ((0.27) as f32))) as f32)
                                                                .clamp(-1.0, 1.0)) as f32)
                                                                + (((((((((__branch_input_11) * ((-0.64) as f32))) as f32)
                                                                    + ((1.5) as f32))) as f32)
                                                                    .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                        let __sc_b = __cse_12;
                                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                    }) as f32;
                                                    let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32)
                                                        + ((compute_overworld__caves__spaghetti_roughness_function(
                                                            noises,
                                                            cache,
                                                            x,
                                                            y,
                                                            z,
                                                        )) as f32))) as f32;
                                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                }) as f32;
                                                let __sc_b = ({
                                                    let __branch_input_13 = (compute_overworld__caves__pillars(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32;
                                                    if __branch_input_13 >= -1000000.0
                                                        && __branch_input_13 < 0.03
                                                    {
                                                        (-1000000.0) as f32
                                                    } else {
                                                        __branch_input_13
                                                    }
                                                }) as f32;
                                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        }
                                    }) as f32
                                } else {
                                    let __lerp_first = (-0.078125) as f32;
                                    __lerp_first
                                        + __lerp_alpha
                                            * ((({
                                                let __branch_input_11 = (compute_overworld__sloped_cheese(
                                                    noises,
                                                    cache,
                                                    x,
                                                    y,
                                                    z,
                                                )) as f32;
                                                let __cse_12 = (compute_overworld__caves__entrances(
                                                    noises,
                                                    cache,
                                                    x,
                                                    y,
                                                    z,
                                                )) as f32;
                                                if __branch_input_11 >= -1000000.0
                                                    && __branch_input_11 < 1.5625
                                                {
                                                    ({
                                                        let __sc_a = __branch_input_11;
                                                        let __sc_b = (((__cse_12) * ((5.0) as f32))) as f32;
                                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                    }) as f32
                                                } else {
                                                    ({
                                                        let __sc_a = ({
                                                            let __sc_a = ({
                                                                let __sc_a = ((((((({
                                                                    let v = (noises
                                                                        .n_cave_layer
                                                                        .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                                    v * v
                                                                }) as f32) * ((4.0) as f32))) as f32)
                                                                    + ((((((((((noises
                                                                        .n_cave_cheese
                                                                        .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                                        as f32) + ((0.27) as f32))) as f32)
                                                                        .clamp(-1.0, 1.0)) as f32)
                                                                        + (((((((((__branch_input_11) * ((-0.64) as f32))) as f32)
                                                                            + ((1.5) as f32))) as f32)
                                                                            .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                                let __sc_b = __cse_12;
                                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                            }) as f32;
                                                            let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                                noises,
                                                                cache,
                                                                x,
                                                                y,
                                                                z,
                                                            )) as f32)
                                                                + ((compute_overworld__caves__spaghetti_roughness_function(
                                                                    noises,
                                                                    cache,
                                                                    x,
                                                                    y,
                                                                    z,
                                                                )) as f32))) as f32;
                                                            if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                        }) as f32;
                                                        let __sc_b = ({
                                                            let __branch_input_13 = (compute_overworld__caves__pillars(
                                                                noises,
                                                                cache,
                                                                x,
                                                                y,
                                                                z,
                                                            )) as f32;
                                                            if __branch_input_13 >= -1000000.0
                                                                && __branch_input_13 < 0.03
                                                            {
                                                                (-1000000.0) as f32
                                                            } else {
                                                                __branch_input_13
                                                            }
                                                        }) as f32;
                                                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                                    }) as f32
                                                }
                                            }) as f32) - __lerp_first)
                                }
                            }) as f32) - __lerp_first)
                }
            }) as f32) as f32) * ((0.64) as f32))) as f32) as f32)
                .clamp(-1.0, 1.0);
            c / 2.0 - c * c * c / 24.0
        }) as f32;
        let __sc_b = (compute_overworld__caves__noodle(noises, cache, x, y, z)) as f32;
        if __sc_a < __sc_b { __sc_a } else { __sc_b }
    }) as f32) + ((0.0) as f32))) as f32
}
///`minecraft:overworld/ore_vein/toggle`
#[inline]
fn compute_overworld__ore_vein__toggle(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __branch_input_14 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_14 >= -64.0 && __branch_input_14 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32
}
///`minecraft:overworld/ore_vein/mask`
#[inline]
fn compute_overworld__ore_vein__mask(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __branch_input_15 = (compute_overworld__ore_vein__toggle(
            noises,
            cache,
            x,
            y,
            z,
        )) as f32;
        if __branch_input_15 >= -0.4 && __branch_input_15 < 0.4 {
            (-1.0) as f32
        } else {
            ((((0.08) as f32)
                - (({
                    let __cse_16 = (compute_y(noises, cache, x, y, z)) as f32;
                    {
                        let __sc_a = (((({
                            let __branch_input_17 = __cse_16;
                            if __branch_input_17 >= -64.0 && __branch_input_17 < 57.0 {
                                (noises.n_ore_vein_a.get_value(x * 4.0, y * 4.0, z * 4.0))
                                    as f32
                            } else {
                                (1.0) as f32
                            }
                        }) as f32) as f32)
                            .abs()) as f32;
                        let __sc_b = (((({
                            let __branch_input_18 = __cse_16;
                            if __branch_input_18 >= -64.0 && __branch_input_18 < 57.0 {
                                (noises.n_ore_vein_b.get_value(x * 4.0, y * 4.0, z * 4.0))
                                    as f32
                            } else {
                                (1.0) as f32
                            }
                        }) as f32) as f32)
                            .abs()) as f32;
                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                    }
                }) as f32))) as f32
        }
    }) as f32
}
///`minecraft:overworld/ore_vein/copper_density`
#[inline]
fn compute_overworld__ore_vein__copper_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __branch_input_19 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_19 >= 0.0 && __branch_input_19 < 50.0 {
            ({
                let __branch_input_20 = (compute_overworld__ore_vein__mask(
                    noises,
                    cache,
                    x,
                    y,
                    z,
                )) as f32;
                if __branch_input_20 >= 0.0 {
                    ({
                        let __branch_input_21 = (((((((compute_overworld__ore_vein__toggle(
                            noises,
                            cache,
                            x,
                            y,
                            z,
                        )) as f32) - ((0.4) as f32))) as f32)
                            + (((((((((({
                                let __sc_a = ((((50.0) as f32) - (__branch_input_19)))
                                    as f32;
                                if __sc_a <= -4064.0 {
                                    __sc_a
                                } else {
                                    let __sc_b = (((__branch_input_19) - ((0.0) as f32)))
                                        as f32;
                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                }
                            }) as f32)
                                .clamp(0.0, 20.0)) as f32) * ((0.01) as f32))) as f32)
                                + ((-0.2) as f32))) as f32))) as f32;
                        if __branch_input_21 >= 0.0 && __branch_input_21 < 1000000.0 {
                            (0.7) as f32
                        } else {
                            (-1.0) as f32
                        }
                    }) as f32
                } else {
                    (-1.0) as f32
                }
            }) as f32
        } else {
            (-1.0) as f32
        }
    }) as f32
}
///`minecraft:overworld/ore_vein/gap`
#[inline]
fn compute_overworld__ore_vein__gap(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ((((-0.3) as f32)
        - ((noises.n_ore_gap.get_value(x * 1.0, y * 1.0, z * 1.0)) as f32))) as f32
}
///`minecraft:overworld/ore_vein/iron_density`
#[inline]
fn compute_overworld__ore_vein__iron_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    ({
        let __branch_input_22 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_22 >= -60.0 && __branch_input_22 < -8.0 {
            ({
                let __branch_input_23 = (compute_overworld__ore_vein__mask(
                    noises,
                    cache,
                    x,
                    y,
                    z,
                )) as f32;
                if __branch_input_23 >= 0.0 {
                    ({
                        let __branch_input_24 = ((((((((-((compute_overworld__ore_vein__toggle(
                            noises,
                            cache,
                            x,
                            y,
                            z,
                        )) as f32))) as f32) - ((0.4) as f32))) as f32)
                            + (((((((((({
                                let __sc_a = ((((-8.0) as f32) - (__branch_input_22)))
                                    as f32;
                                if __sc_a <= -4004.0 {
                                    __sc_a
                                } else {
                                    let __sc_b = (((__branch_input_22) - ((-60.0) as f32)))
                                        as f32;
                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                }
                            }) as f32)
                                .clamp(0.0, 20.0)) as f32) * ((0.01) as f32))) as f32)
                                + ((-0.2) as f32))) as f32))) as f32;
                        if __branch_input_24 >= 0.0 && __branch_input_24 < 1000000.0 {
                            (0.7) as f32
                        } else {
                            (-1.0) as f32
                        }
                    }) as f32
                } else {
                    (-1.0) as f32
                }
            }) as f32
        } else {
            (-1.0) as f32
        }
    }) as f32
}
///`minecraft:overworld/ore_vein/richness`
#[inline]
fn compute_overworld__ore_vein__richness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (((((((((((compute_overworld__ore_vein__toggle(noises, cache, x, y, z)) as f32)
        .abs()) as f32)
        .clamp(0.4, 0.6)) as f32) * ((1.0) as f32))) as f32) + ((-0.3) as f32))) as f32
}
///`minecraft:overworld/preliminary_surface_level`
#[inline]
fn compute_overworld__preliminary_surface_level(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __upper = (((((((((((((((0.2734375) as f32)
            / ((cache.df_overworld__factor) as f32))) as f32)
            - ((cache.df_overworld__offset) as f32))) as f32) * ((-128.0) as f32)))
            as f32) + ((128.0) as f32))) as f32)
            .clamp(-40.0, 320.0)) as f32;
        let __top_y = (__upper / 8 as f32).floor() as i32 * 8;
        if __top_y <= -64 {
            -64 as f32
        } else {
            let mut __result = -64;
            let mut y = __top_y;
            while y >= -64 {
                let __d = (((({
                    let __lerp_alpha = ({
                        let __coordinate = (y as i32).clamp(-64, -40) - -64;
                        0.0 + __coordinate as f32 * ((1.0 - 0.0) / (-40 - -64) as f32)
                    }) as f32;
                    if __lerp_alpha == 0.0 {
                        (0.1171875) as f32
                    } else if __lerp_alpha == 1.0 {
                        ({
                            let __lerp_alpha = ({
                                let __coordinate = (y as i32).clamp(240, 256) - 240;
                                1.0
                                    + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                            }) as f32;
                            if __lerp_alpha == 0.0 {
                                (-0.078125) as f32
                            } else if __lerp_alpha == 1.0 {
                                ((((((((({
                                    let v = ((((((({
                                        let __coordinate = (y as i32).clamp(-64, 320) - -64;
                                        1.5
                                            + __coordinate as f32 * ((-1.5 - 1.5) / (320 - -64) as f32)
                                    }) as f32) + ((cache.df_overworld__offset) as f32))) as f32)
                                        * ((cache.df_overworld__factor) as f32))) as f32;
                                    if v > 0.0 { v } else { v * 0.25 }
                                }) as f32) * ((4.0) as f32))) as f32)
                                    + ((-0.703125) as f32))) as f32)
                                    .clamp(-64.0, 64.0)) as f32
                            } else {
                                let __lerp_first = (-0.078125) as f32;
                                __lerp_first
                                    + __lerp_alpha
                                        * ((((((((((({
                                            let v = ((((((({
                                                let __coordinate = (y as i32).clamp(-64, 320) - -64;
                                                1.5
                                                    + __coordinate as f32 * ((-1.5 - 1.5) / (320 - -64) as f32)
                                            }) as f32) + ((cache.df_overworld__offset) as f32))) as f32)
                                                * ((cache.df_overworld__factor) as f32))) as f32;
                                            if v > 0.0 { v } else { v * 0.25 }
                                        }) as f32) * ((4.0) as f32))) as f32)
                                            + ((-0.703125) as f32))) as f32)
                                            .clamp(-64.0, 64.0)) as f32) - __lerp_first)
                            }
                        }) as f32
                    } else {
                        let __lerp_first = (0.1171875) as f32;
                        __lerp_first
                            + __lerp_alpha
                                * ((({
                                    let __lerp_alpha = ({
                                        let __coordinate = (y as i32).clamp(240, 256) - 240;
                                        1.0
                                            + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                                    }) as f32;
                                    if __lerp_alpha == 0.0 {
                                        (-0.078125) as f32
                                    } else if __lerp_alpha == 1.0 {
                                        ((((((((({
                                            let v = ((((((({
                                                let __coordinate = (y as i32).clamp(-64, 320) - -64;
                                                1.5
                                                    + __coordinate as f32 * ((-1.5 - 1.5) / (320 - -64) as f32)
                                            }) as f32) + ((cache.df_overworld__offset) as f32))) as f32)
                                                * ((cache.df_overworld__factor) as f32))) as f32;
                                            if v > 0.0 { v } else { v * 0.25 }
                                        }) as f32) * ((4.0) as f32))) as f32)
                                            + ((-0.703125) as f32))) as f32)
                                            .clamp(-64.0, 64.0)) as f32
                                    } else {
                                        let __lerp_first = (-0.078125) as f32;
                                        __lerp_first
                                            + __lerp_alpha
                                                * ((((((((((({
                                                    let v = ((((((({
                                                        let __coordinate = (y as i32).clamp(-64, 320) - -64;
                                                        1.5
                                                            + __coordinate as f32 * ((-1.5 - 1.5) / (320 - -64) as f32)
                                                    }) as f32) + ((cache.df_overworld__offset) as f32))) as f32)
                                                        * ((cache.df_overworld__factor) as f32))) as f32;
                                                    if v > 0.0 { v } else { v * 0.25 }
                                                }) as f32) * ((4.0) as f32))) as f32)
                                                    + ((-0.703125) as f32))) as f32)
                                                    .clamp(-64.0, 64.0)) as f32) - __lerp_first)
                                    }
                                }) as f32) - __lerp_first)
                    }
                }) as f32) + ((-0.390625) as f32))) as f32;
                if __d > 0.0 {
                    __result = y;
                    break;
                }
                y -= 8;
            }
            __result as f32
        }
    }) as f32
}
///`minecraft:overworld/temperature`
#[inline]
fn compute_overworld__temperature(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let dx = (cache.df_shift_x) as f32;
        let dz = (cache.df_shift_z) as f32;
        noises
            .n_temperature
            .get_value_xz(x * 0.25 + f64::from(dx), z * 0.25 + f64::from(dz))
    }) as f32
}
///`minecraft:overworld/vegetation`
#[inline]
fn compute_overworld__vegetation(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let dx = (cache.df_shift_x) as f32;
        let dz = (cache.df_shift_z) as f32;
        noises
            .n_vegetation
            .get_value_xz(x * 0.25 + f64::from(dx), z * 0.25 + f64::from(dz))
    }) as f32
}
#[inline]
fn spline_helper_1(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.08880186 + 0.38940096 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.08880186;
            let __y2 = 0.69000006;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.38940096 * __h - (__y2 - __y1);
            let __b = -0.38940096 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.69000006 + 0.38940096 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_2(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.115760356 + 0.37788022 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.115760356;
            let __y2 = 0.6400001;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.37788022 * __h - (__y2 - __y1);
            let __b = -0.37788022 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.6400001 + 0.37788022 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_3(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.2222 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.75 {
            let __y1 = -0.2222;
            let __y2 = -0.2222;
            let __t = (__coord - -1.0) / (-0.75 - -1.0);
            let __h = -0.75 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.65 {
            let __y1 = -0.2222;
            let __y2 = 0.0;
            let __t = (__coord - -0.75) / (-0.65 - -0.75);
            let __h = -0.65 - -0.75;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.5954547 {
            let __y1 = 0.0;
            let __y2 = 0.000000029802322;
            let __t = (__coord - -0.65) / (0.5954547 - -0.65);
            let __h = 0.5954547 - -0.65;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.6054547 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.000000029802322;
            let __t = (__coord - 0.5954547) / (0.6054547 - 0.5954547);
            let __h = 0.6054547 - 0.5954547;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.100000024;
            let __t = (__coord - 0.6054547) / (1.0 - 0.6054547);
            let __h = 1.0 - 0.6054547;
            let __a = 0.2534563 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.100000024 + 0.2534563 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_4(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.3 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.3;
            let __y2 = 0.05;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_5(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.15 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.15;
            let __y2 = 0.0;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.0;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.1 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.1 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_6(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.15 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.15;
            let __y2 = 0.0;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_7(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.02 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.02;
            let __y2 = -0.03;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = -0.03;
            let __y2 = -0.03;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = -0.03;
            let __y2 = 0.0;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.06 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.06 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_0(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.85 {
            f64::from(spline_helper_1(noises, cache, x, z) + 0.0 * (__coord - -0.85))
        } else if __coord < -0.7 {
            let __y1 = spline_helper_1(noises, cache, x, z);
            let __y2 = spline_helper_2(noises, cache, x, z);
            let __t = (__coord - -0.85) / (-0.7 - -0.85);
            let __h = -0.7 - -0.85;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.4 {
            let __y1 = spline_helper_2(noises, cache, x, z);
            let __y2 = spline_helper_3(noises, cache, x, z);
            let __t = (__coord - -0.7) / (-0.4 - -0.7);
            let __h = -0.4 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_3(noises, cache, x, z);
            let __y2 = spline_helper_4(noises, cache, x, z);
            let __t = (__coord - -0.4) / (-0.35 - -0.4);
            let __h = -0.35 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_4(noises, cache, x, z);
            let __y2 = spline_helper_5(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.1 - -0.35);
            let __h = -0.1 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.2 {
            let __y1 = spline_helper_5(noises, cache, x, z);
            let __y2 = spline_helper_6(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.2 - -0.1);
            let __h = 0.2 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.7 {
            let __y1 = spline_helper_6(noises, cache, x, z);
            let __y2 = spline_helper_7(noises, cache, x, z);
            let __t = (__coord - 0.2) / (0.7 - 0.2);
            let __h = 0.7 - 0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_7(noises, cache, x, z) + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_9(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.08880186 + 0.38940096 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.08880186;
            let __y2 = 0.69000006;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.38940096 * __h - (__y2 - __y1);
            let __b = -0.38940096 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.69000006 + 0.38940096 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_10(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.115760356 + 0.37788022 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.115760356;
            let __y2 = 0.6400001;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.37788022 * __h - (__y2 - __y1);
            let __b = -0.37788022 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.6400001 + 0.37788022 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_11(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.2222 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.75 {
            let __y1 = -0.2222;
            let __y2 = -0.2222;
            let __t = (__coord - -1.0) / (-0.75 - -1.0);
            let __h = -0.75 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.65 {
            let __y1 = -0.2222;
            let __y2 = 0.0;
            let __t = (__coord - -0.75) / (-0.65 - -0.75);
            let __h = -0.65 - -0.75;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.5954547 {
            let __y1 = 0.0;
            let __y2 = 0.000000029802322;
            let __t = (__coord - -0.65) / (0.5954547 - -0.65);
            let __h = 0.5954547 - -0.65;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.6054547 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.000000029802322;
            let __t = (__coord - 0.5954547) / (0.6054547 - 0.5954547);
            let __h = 0.6054547 - 0.5954547;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.100000024;
            let __t = (__coord - 0.6054547) / (1.0 - 0.6054547);
            let __h = 1.0 - 0.6054547;
            let __a = 0.2534563 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.100000024 + 0.2534563 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_12(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.3 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.3;
            let __y2 = 0.05;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_13(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.15 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.15;
            let __y2 = 0.0;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.0;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.1 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.1 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_14(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.15 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.15;
            let __y2 = 0.0;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_15(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.02 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.02;
            let __y2 = -0.03;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = -0.03;
            let __y2 = -0.03;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = -0.03;
            let __y2 = 0.0;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.06 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.06 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_8(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.85 {
            f64::from(spline_helper_9(noises, cache, x, z) + 0.0 * (__coord - -0.85))
        } else if __coord < -0.7 {
            let __y1 = spline_helper_9(noises, cache, x, z);
            let __y2 = spline_helper_10(noises, cache, x, z);
            let __t = (__coord - -0.85) / (-0.7 - -0.85);
            let __h = -0.7 - -0.85;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.4 {
            let __y1 = spline_helper_10(noises, cache, x, z);
            let __y2 = spline_helper_11(noises, cache, x, z);
            let __t = (__coord - -0.7) / (-0.4 - -0.7);
            let __h = -0.4 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_11(noises, cache, x, z);
            let __y2 = spline_helper_12(noises, cache, x, z);
            let __t = (__coord - -0.4) / (-0.35 - -0.4);
            let __h = -0.35 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_12(noises, cache, x, z);
            let __y2 = spline_helper_13(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.1 - -0.35);
            let __h = -0.1 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.2 {
            let __y1 = spline_helper_13(noises, cache, x, z);
            let __y2 = spline_helper_14(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.2 - -0.1);
            let __h = 0.2 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.7 {
            let __y1 = spline_helper_14(noises, cache, x, z);
            let __y2 = spline_helper_15(noises, cache, x, z);
            let __t = (__coord - 0.2) / (0.7 - 0.2);
            let __h = 0.7 - 0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_15(noises, cache, x, z) + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_17(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.08880186 + 0.38940096 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.08880186;
            let __y2 = 0.69000006;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.38940096 * __h - (__y2 - __y1);
            let __b = -0.38940096 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.69000006 + 0.38940096 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_18(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.115760356 + 0.37788022 * (__coord - -1.0))
        } else if __coord < 1.0 {
            let __y1 = -0.115760356;
            let __y2 = 0.6400001;
            let __t = (__coord - -1.0) / (1.0 - -1.0);
            let __h = 1.0 - -1.0;
            let __a = 0.37788022 * __h - (__y2 - __y1);
            let __b = -0.37788022 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.6400001 + 0.37788022 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_19(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.2222 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.75 {
            let __y1 = -0.2222;
            let __y2 = -0.2222;
            let __t = (__coord - -1.0) / (-0.75 - -1.0);
            let __h = -0.75 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.65 {
            let __y1 = -0.2222;
            let __y2 = 0.0;
            let __t = (__coord - -0.75) / (-0.65 - -0.75);
            let __h = -0.65 - -0.75;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.5954547 {
            let __y1 = 0.0;
            let __y2 = 0.000000029802322;
            let __t = (__coord - -0.65) / (0.5954547 - -0.65);
            let __h = 0.5954547 - -0.65;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.6054547 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.000000029802322;
            let __t = (__coord - 0.5954547) / (0.6054547 - 0.5954547);
            let __h = 0.6054547 - 0.5954547;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.000000029802322;
            let __y2 = 0.100000024;
            let __t = (__coord - 0.6054547) / (1.0 - 0.6054547);
            let __h = 1.0 - 0.6054547;
            let __a = 0.2534563 * __h - (__y2 - __y1);
            let __b = -0.2534563 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.100000024 + 0.2534563 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_20(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.25 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.25;
            let __y2 = 0.05;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.05;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_21(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.001;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.01 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.001;
            let __y2 = 0.003;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.01 * __h - (__y2 - __y1);
            let __b = -0.01 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.003;
            let __y2 = 0.05;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.01 * __h - (__y2 - __y1);
            let __b = -0.094000004 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.05;
            let __y2 = 0.060000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.094000004 * __h - (__y2 - __y1);
            let __b = -0.007000001 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.060000002 + 0.007000001 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_22(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_23(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.02 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.02;
            let __y2 = -0.03;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = -0.03;
            let __y2 = -0.03;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = -0.03;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.12 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.12 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_16(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.85 {
            f64::from(spline_helper_17(noises, cache, x, z) + 0.0 * (__coord - -0.85))
        } else if __coord < -0.7 {
            let __y1 = spline_helper_17(noises, cache, x, z);
            let __y2 = spline_helper_18(noises, cache, x, z);
            let __t = (__coord - -0.85) / (-0.7 - -0.85);
            let __h = -0.7 - -0.85;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.4 {
            let __y1 = spline_helper_18(noises, cache, x, z);
            let __y2 = spline_helper_19(noises, cache, x, z);
            let __t = (__coord - -0.7) / (-0.4 - -0.7);
            let __h = -0.4 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_19(noises, cache, x, z);
            let __y2 = spline_helper_20(noises, cache, x, z);
            let __t = (__coord - -0.4) / (-0.35 - -0.4);
            let __h = -0.35 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_20(noises, cache, x, z);
            let __y2 = spline_helper_21(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.1 - -0.35);
            let __h = -0.1 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.2 {
            let __y1 = spline_helper_21(noises, cache, x, z);
            let __y2 = spline_helper_22(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.2 - -0.1);
            let __h = 0.2 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.7 {
            let __y1 = spline_helper_22(noises, cache, x, z);
            let __y2 = spline_helper_23(noises, cache, x, z);
            let __t = (__coord - 0.2) / (0.7 - 0.2);
            let __h = 0.7 - 0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_23(noises, cache, x, z) + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_25(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.20235021 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.20235021;
            let __y2 = 0.7161751;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.5138249 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.7161751;
            let __y2 = 1.23;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.5138249 * __h - (__y2 - __y1);
            let __b = -0.5138249 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.23 + 0.5138249 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_26(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.2 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.2;
            let __y2 = 0.44682026;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.43317974 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.44682026;
            let __y2 = 0.88;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.43317974 * __h - (__y2 - __y1);
            let __b = -0.43317974 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.88 + 0.43317974 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_27(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.2 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.2;
            let __y2 = 0.30829495;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.3917051 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.30829495;
            let __y2 = 0.70000005;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.3917051 * __h - (__y2 - __y1);
            let __b = -0.3917051 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.70000005 + 0.3917051 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_28(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.25 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.25;
            let __y2 = 0.35;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.35;
            let __y2 = 0.35;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.35;
            let __y2 = 0.35;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.35;
            let __y2 = 0.42000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.049000014 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.42000002 + 0.049000014 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_29(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.0069999998;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.07 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.0069999998;
            let __y2 = 0.021;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.07 * __h - (__y2 - __y1);
            let __b = -0.07 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.021;
            let __y2 = 0.35;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.07 * __h - (__y2 - __y1);
            let __b = -0.658 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.35;
            let __y2 = 0.42000002;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.658 * __h - (__y2 - __y1);
            let __b = -0.049000014 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.42000002 + 0.049000014 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_30(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_31(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_33(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_32(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = spline_helper_33(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = spline_helper_33(noises, cache, x, z);
            let __y2 = 0.17;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.17 + 0.0 * (__coord - 0.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_35(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_34(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = spline_helper_35(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = spline_helper_35(noises, cache, x, z);
            let __y2 = 0.17;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.17 + 0.0 * (__coord - 0.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_36(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.1 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.1;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_37(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.02 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.02;
            let __y2 = -0.03;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = -0.03;
            let __y2 = -0.03;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = -0.03;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.12 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.12 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_24(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.85 {
            f64::from(spline_helper_25(noises, cache, x, z) + 0.0 * (__coord - -0.85))
        } else if __coord < -0.7 {
            let __y1 = spline_helper_25(noises, cache, x, z);
            let __y2 = spline_helper_26(noises, cache, x, z);
            let __t = (__coord - -0.85) / (-0.7 - -0.85);
            let __h = -0.7 - -0.85;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.4 {
            let __y1 = spline_helper_26(noises, cache, x, z);
            let __y2 = spline_helper_27(noises, cache, x, z);
            let __t = (__coord - -0.7) / (-0.4 - -0.7);
            let __h = -0.4 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_27(noises, cache, x, z);
            let __y2 = spline_helper_28(noises, cache, x, z);
            let __t = (__coord - -0.4) / (-0.35 - -0.4);
            let __h = -0.35 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_28(noises, cache, x, z);
            let __y2 = spline_helper_29(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.1 - -0.35);
            let __h = -0.1 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.2 {
            let __y1 = spline_helper_29(noises, cache, x, z);
            let __y2 = spline_helper_30(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.2 - -0.1);
            let __h = 0.2 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = spline_helper_30(noises, cache, x, z);
            let __y2 = spline_helper_31(noises, cache, x, z);
            let __t = (__coord - 0.2) / (0.4 - 0.2);
            let __h = 0.4 - 0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = spline_helper_31(noises, cache, x, z);
            let __y2 = spline_helper_32(noises, cache, x, z);
            let __t = (__coord - 0.4) / (0.45 - 0.4);
            let __h = 0.45 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_32(noises, cache, x, z);
            let __y2 = spline_helper_34(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.58 {
            let __y1 = spline_helper_34(noises, cache, x, z);
            let __y2 = spline_helper_36(noises, cache, x, z);
            let __t = (__coord - 0.55) / (0.58 - 0.55);
            let __h = 0.58 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.7 {
            let __y1 = spline_helper_36(noises, cache, x, z);
            let __y2 = spline_helper_37(noises, cache, x, z);
            let __t = (__coord - 0.58) / (0.7 - 0.58);
            let __h = 0.7 - 0.58;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_37(noises, cache, x, z) + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_39(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.34792626 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.34792626;
            let __y2 = 0.9239631;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.5760369 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.9239631;
            let __y2 = 1.5;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.5760369 * __h - (__y2 - __y1);
            let __b = -0.5760369 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.5 + 0.5760369 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_40(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.2 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.2;
            let __y2 = 0.5391705;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.4608295 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.5391705;
            let __y2 = 1.0;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.4608295 * __h - (__y2 - __y1);
            let __b = -0.4608295 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.0 + 0.4608295 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_41(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(0.2 + 0.0 * (__coord - -1.0))
        } else if __coord < 0.0 {
            let __y1 = 0.2;
            let __y2 = 0.5391705;
            let __t = (__coord - -1.0) / (0.0 - -1.0);
            let __h = 0.0 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.4608295 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.5391705;
            let __y2 = 1.0;
            let __t = (__coord - 0.0) / (1.0 - 0.0);
            let __h = 1.0 - 0.0;
            let __a = 0.4608295 * __h - (__y2 - __y1);
            let __b = -0.4608295 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.0 + 0.4608295 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_42(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.2 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.2;
            let __y2 = 0.5;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.5;
            let __y2 = 0.5;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.5;
            let __y2 = 0.5;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.5;
            let __y2 = 0.6;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.070000015 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.6 + 0.070000015 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_43(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.099999994 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.099999994 * __h - (__y2 - __y1);
            let __b = -0.099999994 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.03;
            let __y2 = 0.5;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.099999994 * __h - (__y2 - __y1);
            let __b = -0.94 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.5;
            let __y2 = 0.6;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.94 * __h - (__y2 - __y1);
            let __b = -0.070000015 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.6 + 0.070000015 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_44(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_45(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_47(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_46(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = spline_helper_47(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = spline_helper_47(noises, cache, x, z);
            let __y2 = 0.17;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.17 + 0.0 * (__coord - 0.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_49(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_48(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.0 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = spline_helper_49(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = spline_helper_49(noises, cache, x, z);
            let __y2 = 0.17;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.17 + 0.0 * (__coord - 0.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_50(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.05 + 0.5 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.05;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.5 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_51(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -1.0 {
            f64::from(-0.02 + 0.015 * (__coord - -1.0))
        } else if __coord < -0.4 {
            let __y1 = -0.02;
            let __y2 = 0.01;
            let __t = (__coord - -1.0) / (-0.4 - -1.0);
            let __h = -0.4 - -1.0;
            let __a = 0.015 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.0 {
            let __y1 = 0.01;
            let __y2 = 0.01;
            let __t = (__coord - -0.4) / (0.0 - -0.4);
            let __h = 0.0 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = 0.01;
            let __y2 = 0.03;
            let __t = (__coord - 0.0) / (0.4 - 0.0);
            let __h = 0.4 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.04 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.03;
            let __y2 = 0.1;
            let __t = (__coord - 0.4) / (1.0 - 0.4);
            let __h = 1.0 - 0.4;
            let __a = 0.04 * __h - (__y2 - __y1);
            let __b = -0.049 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.1 + 0.049 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_38(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.85 {
            f64::from(spline_helper_39(noises, cache, x, z) + 0.0 * (__coord - -0.85))
        } else if __coord < -0.7 {
            let __y1 = spline_helper_39(noises, cache, x, z);
            let __y2 = spline_helper_40(noises, cache, x, z);
            let __t = (__coord - -0.85) / (-0.7 - -0.85);
            let __h = -0.7 - -0.85;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.4 {
            let __y1 = spline_helper_40(noises, cache, x, z);
            let __y2 = spline_helper_41(noises, cache, x, z);
            let __t = (__coord - -0.7) / (-0.4 - -0.7);
            let __h = -0.4 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_41(noises, cache, x, z);
            let __y2 = spline_helper_42(noises, cache, x, z);
            let __t = (__coord - -0.4) / (-0.35 - -0.4);
            let __h = -0.35 - -0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_42(noises, cache, x, z);
            let __y2 = spline_helper_43(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.1 - -0.35);
            let __h = -0.1 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.2 {
            let __y1 = spline_helper_43(noises, cache, x, z);
            let __y2 = spline_helper_44(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.2 - -0.1);
            let __h = 0.2 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = spline_helper_44(noises, cache, x, z);
            let __y2 = spline_helper_45(noises, cache, x, z);
            let __t = (__coord - 0.2) / (0.4 - 0.2);
            let __h = 0.4 - 0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = spline_helper_45(noises, cache, x, z);
            let __y2 = spline_helper_46(noises, cache, x, z);
            let __t = (__coord - 0.4) / (0.45 - 0.4);
            let __h = 0.45 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_46(noises, cache, x, z);
            let __y2 = spline_helper_48(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.58 {
            let __y1 = spline_helper_48(noises, cache, x, z);
            let __y2 = spline_helper_50(noises, cache, x, z);
            let __t = (__coord - 0.55) / (0.58 - 0.55);
            let __h = 0.58 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.7 {
            let __y1 = spline_helper_50(noises, cache, x, z);
            let __y2 = spline_helper_51(noises, cache, x, z);
            let __t = (__coord - 0.58) / (0.7 - 0.58);
            let __h = 0.7 - 0.58;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_51(noises, cache, x, z) + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_53(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 6.25;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.25 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_54(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(6.3 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 6.3;
            let __y2 = 2.67;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(2.67 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_55(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 6.25;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.25 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_56(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 6.25;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.25 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_57(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(2.67 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 2.67;
            let __y2 = 6.3;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.3 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_58(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 6.25;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.25 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_60(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(6.25 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 6.25;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_59(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(6.25 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 6.25;
            let __y2 = spline_helper_60(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_60(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_62(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(6.25 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 6.25;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_61(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(6.25 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 6.25;
            let __y2 = spline_helper_62(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_62(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_52(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.6 {
            f64::from(spline_helper_53(noises, cache, x, z) + 0.0 * (__coord - -0.6))
        } else if __coord < -0.5 {
            let __y1 = spline_helper_53(noises, cache, x, z);
            let __y2 = spline_helper_54(noises, cache, x, z);
            let __t = (__coord - -0.6) / (-0.5 - -0.6);
            let __h = -0.5 - -0.6;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_54(noises, cache, x, z);
            let __y2 = spline_helper_55(noises, cache, x, z);
            let __t = (__coord - -0.5) / (-0.35 - -0.5);
            let __h = -0.35 - -0.5;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.25 {
            let __y1 = spline_helper_55(noises, cache, x, z);
            let __y2 = spline_helper_56(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.25 - -0.35);
            let __h = -0.25 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_56(noises, cache, x, z);
            let __y2 = spline_helper_57(noises, cache, x, z);
            let __t = (__coord - -0.25) / (-0.1 - -0.25);
            let __h = -0.1 - -0.25;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.03 {
            let __y1 = spline_helper_57(noises, cache, x, z);
            let __y2 = spline_helper_58(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.03 - -0.1);
            let __h = 0.03 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.35 {
            let __y1 = spline_helper_58(noises, cache, x, z);
            let __y2 = 6.25;
            let __t = (__coord - 0.03) / (0.35 - 0.03);
            let __h = 0.35 - 0.03;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = 6.25;
            let __y2 = spline_helper_59(noises, cache, x, z);
            let __t = (__coord - 0.35) / (0.45 - 0.35);
            let __h = 0.45 - 0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_59(noises, cache, x, z);
            let __y2 = spline_helper_61(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.62 {
            let __y1 = spline_helper_61(noises, cache, x, z);
            let __y2 = 6.25;
            let __t = (__coord - 0.55) / (0.62 - 0.55);
            let __h = 0.62 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.25 + 0.0 * (__coord - 0.62))
        }
    }) as f32
}
#[inline]
fn spline_helper_64(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.47;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.47 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_65(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(6.3 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 6.3;
            let __y2 = 2.67;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(2.67 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_66(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.47;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.47 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_67(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.47;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.47 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_68(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(2.67 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 2.67;
            let __y2 = 6.3;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.3 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_69(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.47;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.47 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_71(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(5.47 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 5.47;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_70(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(5.47 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 5.47;
            let __y2 = spline_helper_71(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_71(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_73(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(5.47 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 5.47;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_72(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(5.47 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 5.47;
            let __y2 = spline_helper_73(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_73(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_63(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.6 {
            f64::from(spline_helper_64(noises, cache, x, z) + 0.0 * (__coord - -0.6))
        } else if __coord < -0.5 {
            let __y1 = spline_helper_64(noises, cache, x, z);
            let __y2 = spline_helper_65(noises, cache, x, z);
            let __t = (__coord - -0.6) / (-0.5 - -0.6);
            let __h = -0.5 - -0.6;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_65(noises, cache, x, z);
            let __y2 = spline_helper_66(noises, cache, x, z);
            let __t = (__coord - -0.5) / (-0.35 - -0.5);
            let __h = -0.35 - -0.5;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.25 {
            let __y1 = spline_helper_66(noises, cache, x, z);
            let __y2 = spline_helper_67(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.25 - -0.35);
            let __h = -0.25 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_67(noises, cache, x, z);
            let __y2 = spline_helper_68(noises, cache, x, z);
            let __t = (__coord - -0.25) / (-0.1 - -0.25);
            let __h = -0.1 - -0.25;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.03 {
            let __y1 = spline_helper_68(noises, cache, x, z);
            let __y2 = spline_helper_69(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.03 - -0.1);
            let __h = 0.03 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.35 {
            let __y1 = spline_helper_69(noises, cache, x, z);
            let __y2 = 5.47;
            let __t = (__coord - 0.03) / (0.35 - 0.03);
            let __h = 0.35 - 0.03;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = 5.47;
            let __y2 = spline_helper_70(noises, cache, x, z);
            let __t = (__coord - 0.35) / (0.45 - 0.35);
            let __h = 0.45 - 0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_70(noises, cache, x, z);
            let __y2 = spline_helper_72(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.62 {
            let __y1 = spline_helper_72(noises, cache, x, z);
            let __y2 = 5.47;
            let __t = (__coord - 0.55) / (0.62 - 0.55);
            let __h = 0.62 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.47 + 0.0 * (__coord - 0.62))
        }
    }) as f32
}
#[inline]
fn spline_helper_75(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.08;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.08 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_76(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(6.3 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 6.3;
            let __y2 = 2.67;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(2.67 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_77(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.08;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.08 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_78(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.08;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.08 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_79(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(2.67 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 2.67;
            let __y2 = 6.3;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.3 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_80(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 5.08;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.08 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_82(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(5.08 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 5.08;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_81(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(5.08 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 5.08;
            let __y2 = spline_helper_82(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_82(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_84(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < 0.0 {
            f64::from(5.08 + 0.0 * (__coord - 0.0))
        } else if __coord < 0.1 {
            let __y1 = 5.08;
            let __y2 = 0.625;
            let __t = (__coord - 0.0) / (0.1 - 0.0);
            let __h = 0.1 - 0.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.625 + 0.0 * (__coord - 0.1))
        }
    }) as f32
}
#[inline]
fn spline_helper_83(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.9 {
            f64::from(5.08 + 0.0 * (__coord - -0.9))
        } else if __coord < -0.69 {
            let __y1 = 5.08;
            let __y2 = spline_helper_84(noises, cache, x, z);
            let __t = (__coord - -0.9) / (-0.69 - -0.9);
            let __h = -0.69 - -0.9;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_84(noises, cache, x, z) + 0.0 * (__coord - -0.69))
        }
    }) as f32
}
#[inline]
fn spline_helper_74(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.6 {
            f64::from(spline_helper_75(noises, cache, x, z) + 0.0 * (__coord - -0.6))
        } else if __coord < -0.5 {
            let __y1 = spline_helper_75(noises, cache, x, z);
            let __y2 = spline_helper_76(noises, cache, x, z);
            let __t = (__coord - -0.6) / (-0.5 - -0.6);
            let __h = -0.5 - -0.6;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_76(noises, cache, x, z);
            let __y2 = spline_helper_77(noises, cache, x, z);
            let __t = (__coord - -0.5) / (-0.35 - -0.5);
            let __h = -0.35 - -0.5;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.25 {
            let __y1 = spline_helper_77(noises, cache, x, z);
            let __y2 = spline_helper_78(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.25 - -0.35);
            let __h = -0.25 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_78(noises, cache, x, z);
            let __y2 = spline_helper_79(noises, cache, x, z);
            let __t = (__coord - -0.25) / (-0.1 - -0.25);
            let __h = -0.1 - -0.25;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.03 {
            let __y1 = spline_helper_79(noises, cache, x, z);
            let __y2 = spline_helper_80(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.03 - -0.1);
            let __h = 0.03 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.35 {
            let __y1 = spline_helper_80(noises, cache, x, z);
            let __y2 = 5.08;
            let __t = (__coord - 0.03) / (0.35 - 0.03);
            let __h = 0.35 - 0.03;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = 5.08;
            let __y2 = spline_helper_81(noises, cache, x, z);
            let __t = (__coord - 0.35) / (0.45 - 0.35);
            let __h = 0.45 - 0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_81(noises, cache, x, z);
            let __y2 = spline_helper_83(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.62 {
            let __y1 = spline_helper_83(noises, cache, x, z);
            let __y2 = 5.08;
            let __t = (__coord - 0.55) / (0.62 - 0.55);
            let __h = 0.62 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(5.08 + 0.0 * (__coord - 0.62))
        }
    }) as f32
}
#[inline]
fn spline_helper_86(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_87(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(6.3 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 6.3;
            let __y2 = 2.67;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(2.67 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_88(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_89(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_90(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.05 {
            f64::from(2.67 + 0.0 * (__coord - -0.05))
        } else if __coord < 0.05 {
            let __y1 = 2.67;
            let __y2 = 6.3;
            let __t = (__coord - -0.05) / (0.05 - -0.05);
            let __h = 0.05 - -0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(6.3 + 0.0 * (__coord - 0.05))
        }
    }) as f32
}
#[inline]
fn spline_helper_91(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_93(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_92(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.45 {
            f64::from(spline_helper_93(noises, cache, x, z) + 0.0 * (__coord - 0.45))
        } else if __coord < 0.7 {
            let __y1 = spline_helper_93(noises, cache, x, z);
            let __y2 = 1.56;
            let __t = (__coord - 0.45) / (0.7 - 0.45);
            let __h = 0.7 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.56 + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_95(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_94(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.45 {
            f64::from(spline_helper_95(noises, cache, x, z) + 0.0 * (__coord - 0.45))
        } else if __coord < 0.7 {
            let __y1 = spline_helper_95(noises, cache, x, z);
            let __y2 = 1.56;
            let __t = (__coord - 0.45) / (0.7 - 0.45);
            let __h = 0.7 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.56 + 0.0 * (__coord - 0.7))
        }
    }) as f32
}
#[inline]
fn spline_helper_97(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_96(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.7 {
            f64::from(spline_helper_97(noises, cache, x, z) + 0.0 * (__coord - -0.7))
        } else if __coord < -0.15 {
            let __y1 = spline_helper_97(noises, cache, x, z);
            let __y2 = 1.37;
            let __t = (__coord - -0.7) / (-0.15 - -0.7);
            let __h = -0.15 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.37 + 0.0 * (__coord - -0.15))
        }
    }) as f32
}
#[inline]
fn spline_helper_99(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.2 {
            f64::from(6.3 + 0.0 * (__coord - -0.2))
        } else if __coord < 0.2 {
            let __y1 = 6.3;
            let __y2 = 4.69;
            let __t = (__coord - -0.2) / (0.2 - -0.2);
            let __h = 0.2 - -0.2;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.2))
        }
    }) as f32
}
#[inline]
fn spline_helper_98(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < -0.7 {
            f64::from(spline_helper_99(noises, cache, x, z) + 0.0 * (__coord - -0.7))
        } else if __coord < -0.15 {
            let __y1 = spline_helper_99(noises, cache, x, z);
            let __y2 = 1.37;
            let __t = (__coord - -0.7) / (-0.15 - -0.7);
            let __h = -0.15 - -0.7;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(1.37 + 0.0 * (__coord - -0.15))
        }
    }) as f32
}
#[inline]
fn spline_helper_85(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -0.6 {
            f64::from(spline_helper_86(noises, cache, x, z) + 0.0 * (__coord - -0.6))
        } else if __coord < -0.5 {
            let __y1 = spline_helper_86(noises, cache, x, z);
            let __y2 = spline_helper_87(noises, cache, x, z);
            let __t = (__coord - -0.6) / (-0.5 - -0.6);
            let __h = -0.5 - -0.6;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.35 {
            let __y1 = spline_helper_87(noises, cache, x, z);
            let __y2 = spline_helper_88(noises, cache, x, z);
            let __t = (__coord - -0.5) / (-0.35 - -0.5);
            let __h = -0.35 - -0.5;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.25 {
            let __y1 = spline_helper_88(noises, cache, x, z);
            let __y2 = spline_helper_89(noises, cache, x, z);
            let __t = (__coord - -0.35) / (-0.25 - -0.35);
            let __h = -0.25 - -0.35;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.1 {
            let __y1 = spline_helper_89(noises, cache, x, z);
            let __y2 = spline_helper_90(noises, cache, x, z);
            let __t = (__coord - -0.25) / (-0.1 - -0.25);
            let __h = -0.1 - -0.25;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.03 {
            let __y1 = spline_helper_90(noises, cache, x, z);
            let __y2 = spline_helper_91(noises, cache, x, z);
            let __t = (__coord - -0.1) / (0.03 - -0.1);
            let __h = 0.03 - -0.1;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.05 {
            let __y1 = spline_helper_91(noises, cache, x, z);
            let __y2 = spline_helper_92(noises, cache, x, z);
            let __t = (__coord - 0.03) / (0.05 - 0.03);
            let __h = 0.05 - 0.03;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.4 {
            let __y1 = spline_helper_92(noises, cache, x, z);
            let __y2 = spline_helper_94(noises, cache, x, z);
            let __t = (__coord - 0.05) / (0.4 - 0.05);
            let __h = 0.4 - 0.05;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.45 {
            let __y1 = spline_helper_94(noises, cache, x, z);
            let __y2 = spline_helper_96(noises, cache, x, z);
            let __t = (__coord - 0.4) / (0.45 - 0.4);
            let __h = 0.45 - 0.4;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.55 {
            let __y1 = spline_helper_96(noises, cache, x, z);
            let __y2 = spline_helper_98(noises, cache, x, z);
            let __t = (__coord - 0.45) / (0.55 - 0.45);
            let __h = 0.55 - 0.45;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 0.58 {
            let __y1 = spline_helper_98(noises, cache, x, z);
            let __y2 = 4.69;
            let __t = (__coord - 0.55) / (0.58 - 0.55);
            let __h = 0.58 - 0.55;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(4.69 + 0.0 * (__coord - 0.58))
        }
    }) as f32
}
#[inline]
fn spline_helper_102(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.63 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.63;
            let __y2 = 0.3;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.3 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_101(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = spline_helper_102(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_102(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_104(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.315 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.315;
            let __y2 = 0.15;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.15 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_103(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = spline_helper_104(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_104(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_106(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.315 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.315;
            let __y2 = 0.15;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.15 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_105(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = spline_helper_106(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_106(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_100(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -1.0 {
            f64::from(spline_helper_101(noises, cache, x, z) + 0.0 * (__coord - -1.0))
        } else if __coord < -0.78 {
            let __y1 = spline_helper_101(noises, cache, x, z);
            let __y2 = spline_helper_103(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.78 - -1.0);
            let __h = -0.78 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.5775 {
            let __y1 = spline_helper_103(noises, cache, x, z);
            let __y2 = spline_helper_105(noises, cache, x, z);
            let __t = (__coord - -0.78) / (-0.5775 - -0.78);
            let __h = -0.5775 - -0.78;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.375 {
            let __y1 = spline_helper_105(noises, cache, x, z);
            let __y2 = 0.0;
            let __t = (__coord - -0.5775) / (-0.375 - -0.5775);
            let __h = -0.375 - -0.5775;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - -0.375))
        }
    }) as f32
}
#[inline]
fn spline_helper_109(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.63 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.63;
            let __y2 = 0.3;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.3 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_110(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.63 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.63;
            let __y2 = 0.3;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.3 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_108(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = spline_helper_109(noises, cache, x, z);
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = spline_helper_109(noises, cache, x, z);
            let __y2 = spline_helper_110(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_110(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_112(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.63 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.63;
            let __y2 = 0.3;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.3 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_111(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = spline_helper_112(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_112(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_114(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges) as f32) as f32;
        if __coord < -0.01 {
            f64::from(0.63 + 0.0 * (__coord - -0.01))
        } else if __coord < 0.01 {
            let __y1 = 0.63;
            let __y2 = 0.3;
            let __t = (__coord - -0.01) / (0.01 - -0.01);
            let __h = 0.01 - -0.01;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.3 + 0.0 * (__coord - 0.01))
        }
    }) as f32
}
#[inline]
fn spline_helper_113(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__ridges_folded) as f32) as f32;
        if __coord < 0.19999999 {
            f64::from(0.0 + 0.0 * (__coord - 0.19999999))
        } else if __coord < 0.44999996 {
            let __y1 = 0.0;
            let __y2 = 0.0;
            let __t = (__coord - 0.19999999) / (0.44999996 - 0.19999999);
            let __h = 0.44999996 - 0.19999999;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < 1.0 {
            let __y1 = 0.0;
            let __y2 = spline_helper_114(noises, cache, x, z);
            let __t = (__coord - 0.44999996) / (1.0 - 0.44999996);
            let __h = 1.0 - 0.44999996;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(spline_helper_114(noises, cache, x, z) + 0.0 * (__coord - 1.0))
        }
    }) as f32
}
#[inline]
fn spline_helper_107(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    ({
        let __coord = ((cache.df_overworld__erosion) as f32) as f32;
        if __coord < -1.0 {
            f64::from(spline_helper_108(noises, cache, x, z) + 0.0 * (__coord - -1.0))
        } else if __coord < -0.78 {
            let __y1 = spline_helper_108(noises, cache, x, z);
            let __y2 = spline_helper_111(noises, cache, x, z);
            let __t = (__coord - -1.0) / (-0.78 - -1.0);
            let __h = -0.78 - -1.0;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.5775 {
            let __y1 = spline_helper_111(noises, cache, x, z);
            let __y2 = spline_helper_113(noises, cache, x, z);
            let __t = (__coord - -0.78) / (-0.5775 - -0.78);
            let __h = -0.5775 - -0.78;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else if __coord < -0.375 {
            let __y1 = spline_helper_113(noises, cache, x, z);
            let __y2 = 0.0;
            let __t = (__coord - -0.5775) / (-0.375 - -0.5775);
            let __h = -0.375 - -0.5775;
            let __a = 0.0 * __h - (__y2 - __y1);
            let __b = -0.0 * __h + (__y2 - __y1);
            let __lerp_y = __y1 + __t * (__y2 - __y1);
            let __lerp_ab = __a + __t * (__b - __a);
            f64::from(__lerp_y + __t * (1.0_f32 - __t) * __lerp_ab)
        } else {
            f64::from(0.0 + 0.0 * (__coord - -0.375))
        }
    }) as f32
}
#[inline]
fn compute_overworld__base_3d_noise_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __ys_arr = ys.to_array();
        let mut __values = [0.0_f32; N];
        for lane in 0..N {
            #[allow(clippy::cast_possible_truncation)]
            let y = __ys_arr[lane];
            __values[lane] = (noises.blended_noise.compute(x, y, z) as f32) as f32;
        }
        Simd::from_array(__values)
    }
}
#[inline]
fn compute_overworld__caves__spaghetti_roughness_function_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((((((noises
        .n_spaghetti_roughness_modulator
        .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
        * (Simd::<f32, N>::splat(-0.05)))) + (Simd::<f32, N>::splat(-0.05))))
        * ((((noises
            .n_spaghetti_roughness
            .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
            .abs()) + (Simd::<f32, N>::splat(-0.4)))))
}
#[inline]
fn compute_overworld__caves__entrances_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    (((((noises
        .n_cave_entrance
        .get_value_y_simd(x * 0.75, ys * Simd::<f64, N>::splat(0.5), z * 0.75))
        + (Simd::<f32, N>::splat(0.37))))
        + ({
            let __coordinate = ys
                .cast::<i32>()
                .simd_max(Simd::splat(-10))
                .simd_min(Simd::splat(30)) - Simd::splat(-10);
            Simd::<f32, N>::splat(0.3)
                + __coordinate.cast::<f32>()
                    * Simd::<f32, N>::splat((0.0 - 0.3) / (30 - -10) as f32)
        })))
        .simd_min(
            ((compute_overworld__caves__spaghetti_roughness_function_simd::<
                N,
            >(noises, cache, x, ys, z))
                + (((({
                    let __cse_25 = noises
                        .n_spaghetti_3d_rarity
                        .get_value_y_simd(
                            x * 2.0,
                            ys * Simd::<f64, N>::splat(1.0),
                            z * 2.0,
                        );
                    (({
                        let __branch_input_26 = __cse_25;
                        {
                            let __below_mask = __branch_input_26
                                .simd_lt(Simd::<f32, N>::splat(-0.5));
                            if __below_mask.all() {
                                ((noises
                                    .n_spaghetti_3d_1
                                    .get_value_y_simd(
                                        x * 1.3333333333333333,
                                        ys * Simd::<f64, N>::splat(1.3333333333333333),
                                        z * 1.3333333333333333,
                                    )) * (Simd::<f32, N>::splat(0.75)))
                            } else if !__below_mask.any() {
                                {
                                    let __below_mask = __branch_input_26
                                        .simd_lt(Simd::<f32, N>::splat(0.0));
                                    if __below_mask.all() {
                                        ((noises
                                            .n_spaghetti_3d_1
                                            .get_value_y_simd(
                                                x * 1.0,
                                                ys * Simd::<f64, N>::splat(1.0),
                                                z * 1.0,
                                            )) * (Simd::<f32, N>::splat(1.0)))
                                    } else if !__below_mask.any() {
                                        {
                                            let __below_mask = __branch_input_26
                                                .simd_lt(Simd::<f32, N>::splat(0.5));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)))
                                            } else if !__below_mask.any() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)))
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)));
                                                let __above = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)));
                                                __below_mask.select(__below, __above)
                                            }
                                        }
                                    } else {
                                        let __below = ((noises
                                            .n_spaghetti_3d_1
                                            .get_value_y_simd(
                                                x * 1.0,
                                                ys * Simd::<f64, N>::splat(1.0),
                                                z * 1.0,
                                            )) * (Simd::<f32, N>::splat(1.0)));
                                        let __above = {
                                            let __below_mask = __branch_input_26
                                                .simd_lt(Simd::<f32, N>::splat(0.5));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)))
                                            } else if !__below_mask.any() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)))
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)));
                                                let __above = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)));
                                                __below_mask.select(__below, __above)
                                            }
                                        };
                                        __below_mask.select(__below, __above)
                                    }
                                }
                            } else {
                                let __below = ((noises
                                    .n_spaghetti_3d_1
                                    .get_value_y_simd(
                                        x * 1.3333333333333333,
                                        ys * Simd::<f64, N>::splat(1.3333333333333333),
                                        z * 1.3333333333333333,
                                    )) * (Simd::<f32, N>::splat(0.75)));
                                let __above = {
                                    let __below_mask = __branch_input_26
                                        .simd_lt(Simd::<f32, N>::splat(0.0));
                                    if __below_mask.all() {
                                        ((noises
                                            .n_spaghetti_3d_1
                                            .get_value_y_simd(
                                                x * 1.0,
                                                ys * Simd::<f64, N>::splat(1.0),
                                                z * 1.0,
                                            )) * (Simd::<f32, N>::splat(1.0)))
                                    } else if !__below_mask.any() {
                                        {
                                            let __below_mask = __branch_input_26
                                                .simd_lt(Simd::<f32, N>::splat(0.5));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)))
                                            } else if !__below_mask.any() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)))
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)));
                                                let __above = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)));
                                                __below_mask.select(__below, __above)
                                            }
                                        }
                                    } else {
                                        let __below = ((noises
                                            .n_spaghetti_3d_1
                                            .get_value_y_simd(
                                                x * 1.0,
                                                ys * Simd::<f64, N>::splat(1.0),
                                                z * 1.0,
                                            )) * (Simd::<f32, N>::splat(1.0)));
                                        let __above = {
                                            let __below_mask = __branch_input_26
                                                .simd_lt(Simd::<f32, N>::splat(0.5));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)))
                                            } else if !__below_mask.any() {
                                                ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)))
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.6666666666666666,
                                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                        z * 0.6666666666666666,
                                                    )) * (Simd::<f32, N>::splat(1.5)));
                                                let __above = ((noises
                                                    .n_spaghetti_3d_1
                                                    .get_value_y_simd(
                                                        x * 0.5,
                                                        ys * Simd::<f64, N>::splat(0.5),
                                                        z * 0.5,
                                                    )) * (Simd::<f32, N>::splat(2.0)));
                                                __below_mask.select(__below, __above)
                                            }
                                        };
                                        __below_mask.select(__below, __above)
                                    }
                                };
                                __below_mask.select(__below, __above)
                            }
                        }
                    })
                        .abs())
                        .simd_max(
                            ({
                                let __branch_input_27 = __cse_25;
                                {
                                    let __below_mask = __branch_input_27
                                        .simd_lt(Simd::<f32, N>::splat(-0.5));
                                    if __below_mask.all() {
                                        ((noises
                                            .n_spaghetti_3d_2
                                            .get_value_y_simd(
                                                x * 1.3333333333333333,
                                                ys * Simd::<f64, N>::splat(1.3333333333333333),
                                                z * 1.3333333333333333,
                                            )) * (Simd::<f32, N>::splat(0.75)))
                                    } else if !__below_mask.any() {
                                        {
                                            let __below_mask = __branch_input_27
                                                .simd_lt(Simd::<f32, N>::splat(0.0));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_2
                                                    .get_value_y_simd(
                                                        x * 1.0,
                                                        ys * Simd::<f64, N>::splat(1.0),
                                                        z * 1.0,
                                                    )) * (Simd::<f32, N>::splat(1.0)))
                                            } else if !__below_mask.any() {
                                                {
                                                    let __below_mask = __branch_input_27
                                                        .simd_lt(Simd::<f32, N>::splat(0.5));
                                                    if __below_mask.all() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)))
                                                    } else if !__below_mask.any() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)))
                                                    } else {
                                                        let __below = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)));
                                                        let __above = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)));
                                                        __below_mask.select(__below, __above)
                                                    }
                                                }
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_2
                                                    .get_value_y_simd(
                                                        x * 1.0,
                                                        ys * Simd::<f64, N>::splat(1.0),
                                                        z * 1.0,
                                                    )) * (Simd::<f32, N>::splat(1.0)));
                                                let __above = {
                                                    let __below_mask = __branch_input_27
                                                        .simd_lt(Simd::<f32, N>::splat(0.5));
                                                    if __below_mask.all() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)))
                                                    } else if !__below_mask.any() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)))
                                                    } else {
                                                        let __below = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)));
                                                        let __above = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)));
                                                        __below_mask.select(__below, __above)
                                                    }
                                                };
                                                __below_mask.select(__below, __above)
                                            }
                                        }
                                    } else {
                                        let __below = ((noises
                                            .n_spaghetti_3d_2
                                            .get_value_y_simd(
                                                x * 1.3333333333333333,
                                                ys * Simd::<f64, N>::splat(1.3333333333333333),
                                                z * 1.3333333333333333,
                                            )) * (Simd::<f32, N>::splat(0.75)));
                                        let __above = {
                                            let __below_mask = __branch_input_27
                                                .simd_lt(Simd::<f32, N>::splat(0.0));
                                            if __below_mask.all() {
                                                ((noises
                                                    .n_spaghetti_3d_2
                                                    .get_value_y_simd(
                                                        x * 1.0,
                                                        ys * Simd::<f64, N>::splat(1.0),
                                                        z * 1.0,
                                                    )) * (Simd::<f32, N>::splat(1.0)))
                                            } else if !__below_mask.any() {
                                                {
                                                    let __below_mask = __branch_input_27
                                                        .simd_lt(Simd::<f32, N>::splat(0.5));
                                                    if __below_mask.all() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)))
                                                    } else if !__below_mask.any() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)))
                                                    } else {
                                                        let __below = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)));
                                                        let __above = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)));
                                                        __below_mask.select(__below, __above)
                                                    }
                                                }
                                            } else {
                                                let __below = ((noises
                                                    .n_spaghetti_3d_2
                                                    .get_value_y_simd(
                                                        x * 1.0,
                                                        ys * Simd::<f64, N>::splat(1.0),
                                                        z * 1.0,
                                                    )) * (Simd::<f32, N>::splat(1.0)));
                                                let __above = {
                                                    let __below_mask = __branch_input_27
                                                        .simd_lt(Simd::<f32, N>::splat(0.5));
                                                    if __below_mask.all() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)))
                                                    } else if !__below_mask.any() {
                                                        ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)))
                                                    } else {
                                                        let __below = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.6666666666666666,
                                                                ys * Simd::<f64, N>::splat(0.6666666666666666),
                                                                z * 0.6666666666666666,
                                                            )) * (Simd::<f32, N>::splat(1.5)));
                                                        let __above = ((noises
                                                            .n_spaghetti_3d_2
                                                            .get_value_y_simd(
                                                                x * 0.5,
                                                                ys * Simd::<f64, N>::splat(0.5),
                                                                z * 0.5,
                                                            )) * (Simd::<f32, N>::splat(2.0)));
                                                        __below_mask.select(__below, __above)
                                                    }
                                                };
                                                __below_mask.select(__below, __above)
                                            }
                                        };
                                        __below_mask.select(__below, __above)
                                    }
                                }
                            })
                                .abs(),
                        )
                })
                    + (((((noises
                        .n_spaghetti_3d_thickness
                        .get_value_y_simd(
                            x * 1.0,
                            ys * Simd::<f64, N>::splat(1.0),
                            z * 1.0,
                        )) * (Simd::<f32, N>::splat(-0.011500001))))
                        + (Simd::<f32, N>::splat(-0.0765))))))
                    .simd_max(Simd::<f32, N>::splat(-1.0))
                    .simd_min(Simd::<f32, N>::splat(1.0)))),
        )
}
#[inline]
fn compute_y_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __coordinate = ys
            .cast::<i32>()
            .simd_max(Simd::splat(-4064))
            .simd_min(Simd::splat(4062)) - Simd::splat(-4064);
        Simd::<f32, N>::splat(-4064.0)
            + __coordinate.cast::<f32>()
                * Simd::<f32, N>::splat((4062.0 - -4064.0) / (4062 - -4064) as f32)
    }
}
#[inline]
fn compute_overworld__caves__noodle_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __branch_input_29 = {
            let __branch_input_28 = compute_y_simd::<N>(noises, cache, x, ys, z);
            let __in_mask = __branch_input_28.simd_ge(Simd::<f32, N>::splat(-60.0))
                & __branch_input_28.simd_lt(Simd::<f32, N>::splat(321.0));
            if __in_mask.all() {
                noises
                    .n_noodle
                    .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0)
            } else if !__in_mask.any() {
                Simd::<f32, N>::splat(-1.0)
            } else {
                let __ir = noises
                    .n_noodle
                    .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0);
                let __or = Simd::<f32, N>::splat(-1.0);
                __in_mask.select(__ir, __or)
            }
        };
        let __in_mask = __branch_input_29.simd_ge(Simd::<f32, N>::splat(-1000000.0))
            & __branch_input_29.simd_lt(Simd::<f32, N>::splat(0.0));
        if __in_mask.all() {
            Simd::<f32, N>::splat(64.0)
        } else if !__in_mask.any() {
            {
                let __cse_30 = compute_y_simd::<N>(noises, cache, x, ys, z);
                (({
                    let __branch_input_31 = __cse_30;
                    let __in_mask = __branch_input_31
                        .simd_ge(Simd::<f32, N>::splat(-60.0))
                        & __branch_input_31.simd_lt(Simd::<f32, N>::splat(321.0));
                    if __in_mask.all() {
                        ((((noises
                            .n_noodle_thickness
                            .get_value_y_simd(
                                x * 1.0,
                                ys * Simd::<f64, N>::splat(1.0),
                                z * 1.0,
                            )) * (Simd::<f32, N>::splat(-0.025))))
                            + (Simd::<f32, N>::splat(-0.075)))
                    } else if !__in_mask.any() {
                        Simd::<f32, N>::splat(0.0)
                    } else {
                        let __ir = ((((noises
                            .n_noodle_thickness
                            .get_value_y_simd(
                                x * 1.0,
                                ys * Simd::<f64, N>::splat(1.0),
                                z * 1.0,
                            )) * (Simd::<f32, N>::splat(-0.025))))
                            + (Simd::<f32, N>::splat(-0.075)));
                        let __or = Simd::<f32, N>::splat(0.0);
                        __in_mask.select(__ir, __or)
                    }
                })
                    + ((((({
                        let __branch_input_32 = __cse_30;
                        let __in_mask = __branch_input_32
                            .simd_ge(Simd::<f32, N>::splat(-60.0))
                            & __branch_input_32.simd_lt(Simd::<f32, N>::splat(321.0));
                        if __in_mask.all() {
                            noises
                                .n_noodle_ridge_a
                                .get_value_y_simd(
                                    x * 2.6666666666666665,
                                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                                    z * 2.6666666666666665,
                                )
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(0.0)
                        } else {
                            let __ir = noises
                                .n_noodle_ridge_a
                                .get_value_y_simd(
                                    x * 2.6666666666666665,
                                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                                    z * 2.6666666666666665,
                                );
                            let __or = Simd::<f32, N>::splat(0.0);
                            __in_mask.select(__ir, __or)
                        }
                    })
                        .abs())
                        .simd_max(
                            ({
                                let __branch_input_33 = __cse_30;
                                let __in_mask = __branch_input_33
                                    .simd_ge(Simd::<f32, N>::splat(-60.0))
                                    & __branch_input_33.simd_lt(Simd::<f32, N>::splat(321.0));
                                if __in_mask.all() {
                                    noises
                                        .n_noodle_ridge_b
                                        .get_value_y_simd(
                                            x * 2.6666666666666665,
                                            ys * Simd::<f64, N>::splat(2.6666666666666665),
                                            z * 2.6666666666666665,
                                        )
                                } else if !__in_mask.any() {
                                    Simd::<f32, N>::splat(0.0)
                                } else {
                                    let __ir = noises
                                        .n_noodle_ridge_b
                                        .get_value_y_simd(
                                            x * 2.6666666666666665,
                                            ys * Simd::<f64, N>::splat(2.6666666666666665),
                                            z * 2.6666666666666665,
                                        );
                                    let __or = Simd::<f32, N>::splat(0.0);
                                    __in_mask.select(__ir, __or)
                                }
                            })
                                .abs(),
                        )) * (Simd::<f32, N>::splat(1.5)))))
            }
        } else {
            let __ir = Simd::<f32, N>::splat(64.0);
            let __or = {
                let __cse_30 = compute_y_simd::<N>(noises, cache, x, ys, z);
                (({
                    let __branch_input_31 = __cse_30;
                    let __in_mask = __branch_input_31
                        .simd_ge(Simd::<f32, N>::splat(-60.0))
                        & __branch_input_31.simd_lt(Simd::<f32, N>::splat(321.0));
                    if __in_mask.all() {
                        ((((noises
                            .n_noodle_thickness
                            .get_value_y_simd(
                                x * 1.0,
                                ys * Simd::<f64, N>::splat(1.0),
                                z * 1.0,
                            )) * (Simd::<f32, N>::splat(-0.025))))
                            + (Simd::<f32, N>::splat(-0.075)))
                    } else if !__in_mask.any() {
                        Simd::<f32, N>::splat(0.0)
                    } else {
                        let __ir = ((((noises
                            .n_noodle_thickness
                            .get_value_y_simd(
                                x * 1.0,
                                ys * Simd::<f64, N>::splat(1.0),
                                z * 1.0,
                            )) * (Simd::<f32, N>::splat(-0.025))))
                            + (Simd::<f32, N>::splat(-0.075)));
                        let __or = Simd::<f32, N>::splat(0.0);
                        __in_mask.select(__ir, __or)
                    }
                })
                    + ((((({
                        let __branch_input_32 = __cse_30;
                        let __in_mask = __branch_input_32
                            .simd_ge(Simd::<f32, N>::splat(-60.0))
                            & __branch_input_32.simd_lt(Simd::<f32, N>::splat(321.0));
                        if __in_mask.all() {
                            noises
                                .n_noodle_ridge_a
                                .get_value_y_simd(
                                    x * 2.6666666666666665,
                                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                                    z * 2.6666666666666665,
                                )
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(0.0)
                        } else {
                            let __ir = noises
                                .n_noodle_ridge_a
                                .get_value_y_simd(
                                    x * 2.6666666666666665,
                                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                                    z * 2.6666666666666665,
                                );
                            let __or = Simd::<f32, N>::splat(0.0);
                            __in_mask.select(__ir, __or)
                        }
                    })
                        .abs())
                        .simd_max(
                            ({
                                let __branch_input_33 = __cse_30;
                                let __in_mask = __branch_input_33
                                    .simd_ge(Simd::<f32, N>::splat(-60.0))
                                    & __branch_input_33.simd_lt(Simd::<f32, N>::splat(321.0));
                                if __in_mask.all() {
                                    noises
                                        .n_noodle_ridge_b
                                        .get_value_y_simd(
                                            x * 2.6666666666666665,
                                            ys * Simd::<f64, N>::splat(2.6666666666666665),
                                            z * 2.6666666666666665,
                                        )
                                } else if !__in_mask.any() {
                                    Simd::<f32, N>::splat(0.0)
                                } else {
                                    let __ir = noises
                                        .n_noodle_ridge_b
                                        .get_value_y_simd(
                                            x * 2.6666666666666665,
                                            ys * Simd::<f64, N>::splat(2.6666666666666665),
                                            z * 2.6666666666666665,
                                        );
                                    let __or = Simd::<f32, N>::splat(0.0);
                                    __in_mask.select(__ir, __or)
                                }
                            })
                                .abs(),
                        )) * (Simd::<f32, N>::splat(1.5)))))
            };
            __in_mask.select(__ir, __or)
        }
    }
}
#[inline]
fn compute_overworld__caves__pillars_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((((((noises
        .n_pillar
        .get_value_y_simd(x * 25.0, ys * Simd::<f64, N>::splat(0.3), z * 25.0))
        * (Simd::<f32, N>::splat(2.0))))
        + (((((noises
            .n_pillar_rareness
            .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
            * (Simd::<f32, N>::splat(-1.0)))) + (Simd::<f32, N>::splat(-1.0))))))
        * ({
            let __v = ((((noises
                .n_pillar_thickness
                .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
                * (Simd::<f32, N>::splat(0.55)))) + (Simd::<f32, N>::splat(0.55)));
            __v * __v * __v
        }))
}
#[inline]
fn compute_overworld__caves__spaghetti_2d_thickness_modulator_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((((noises
        .n_spaghetti_2d_thickness
        .get_value_y_simd(x * 2.0, ys * Simd::<f64, N>::splat(1.0), z * 2.0))
        * (Simd::<f32, N>::splat(-0.34999996)))) + (Simd::<f32, N>::splat(-0.95)))
}
#[inline]
fn compute_overworld__caves__spaghetti_2d_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ({
        let __cse_34 = compute_overworld__caves__spaghetti_2d_thickness_modulator_simd::<
            N,
        >(noises, cache, x, ys, z);
        (((({
            let __branch_input_35 = noises
                .n_spaghetti_2d_modulator
                .get_value_y_simd(x * 2.0, ys * Simd::<f64, N>::splat(1.0), z * 2.0);
            {
                let __below_mask = __branch_input_35
                    .simd_lt(Simd::<f32, N>::splat(-0.75));
                if __below_mask.all() {
                    ((noises
                        .n_spaghetti_2d
                        .get_value_y_simd(
                            x * 2.0,
                            ys * Simd::<f64, N>::splat(2.0),
                            z * 2.0,
                        )) * (Simd::<f32, N>::splat(0.5)))
                } else if !__below_mask.any() {
                    {
                        let __below_mask = __branch_input_35
                            .simd_lt(Simd::<f32, N>::splat(-0.5));
                        if __below_mask.all() {
                            ((noises
                                .n_spaghetti_2d
                                .get_value_y_simd(
                                    x * 1.3333333333333333,
                                    ys * Simd::<f64, N>::splat(1.3333333333333333),
                                    z * 1.3333333333333333,
                                )) * (Simd::<f32, N>::splat(0.75)))
                        } else if !__below_mask.any() {
                            {
                                let __below_mask = __branch_input_35
                                    .simd_lt(Simd::<f32, N>::splat(0.5));
                                if __below_mask.all() {
                                    ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)))
                                } else if !__below_mask.any() {
                                    {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    }
                                } else {
                                    let __below = ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)));
                                    let __above = {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    };
                                    __below_mask.select(__below, __above)
                                }
                            }
                        } else {
                            let __below = ((noises
                                .n_spaghetti_2d
                                .get_value_y_simd(
                                    x * 1.3333333333333333,
                                    ys * Simd::<f64, N>::splat(1.3333333333333333),
                                    z * 1.3333333333333333,
                                )) * (Simd::<f32, N>::splat(0.75)));
                            let __above = {
                                let __below_mask = __branch_input_35
                                    .simd_lt(Simd::<f32, N>::splat(0.5));
                                if __below_mask.all() {
                                    ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)))
                                } else if !__below_mask.any() {
                                    {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    }
                                } else {
                                    let __below = ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)));
                                    let __above = {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    };
                                    __below_mask.select(__below, __above)
                                }
                            };
                            __below_mask.select(__below, __above)
                        }
                    }
                } else {
                    let __below = ((noises
                        .n_spaghetti_2d
                        .get_value_y_simd(
                            x * 2.0,
                            ys * Simd::<f64, N>::splat(2.0),
                            z * 2.0,
                        )) * (Simd::<f32, N>::splat(0.5)));
                    let __above = {
                        let __below_mask = __branch_input_35
                            .simd_lt(Simd::<f32, N>::splat(-0.5));
                        if __below_mask.all() {
                            ((noises
                                .n_spaghetti_2d
                                .get_value_y_simd(
                                    x * 1.3333333333333333,
                                    ys * Simd::<f64, N>::splat(1.3333333333333333),
                                    z * 1.3333333333333333,
                                )) * (Simd::<f32, N>::splat(0.75)))
                        } else if !__below_mask.any() {
                            {
                                let __below_mask = __branch_input_35
                                    .simd_lt(Simd::<f32, N>::splat(0.5));
                                if __below_mask.all() {
                                    ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)))
                                } else if !__below_mask.any() {
                                    {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    }
                                } else {
                                    let __below = ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)));
                                    let __above = {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    };
                                    __below_mask.select(__below, __above)
                                }
                            }
                        } else {
                            let __below = ((noises
                                .n_spaghetti_2d
                                .get_value_y_simd(
                                    x * 1.3333333333333333,
                                    ys * Simd::<f64, N>::splat(1.3333333333333333),
                                    z * 1.3333333333333333,
                                )) * (Simd::<f32, N>::splat(0.75)));
                            let __above = {
                                let __below_mask = __branch_input_35
                                    .simd_lt(Simd::<f32, N>::splat(0.5));
                                if __below_mask.all() {
                                    ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)))
                                } else if !__below_mask.any() {
                                    {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    }
                                } else {
                                    let __below = ((noises
                                        .n_spaghetti_2d
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(1.0),
                                            z * 1.0,
                                        )) * (Simd::<f32, N>::splat(1.0)));
                                    let __above = {
                                        let __below_mask = __branch_input_35
                                            .simd_lt(Simd::<f32, N>::splat(0.75));
                                        if __below_mask.all() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)))
                                        } else if !__below_mask.any() {
                                            ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)))
                                        } else {
                                            let __below = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.5,
                                                    ys * Simd::<f64, N>::splat(0.5),
                                                    z * 0.5,
                                                )) * (Simd::<f32, N>::splat(2.0)));
                                            let __above = ((noises
                                                .n_spaghetti_2d
                                                .get_value_y_simd(
                                                    x * 0.3333333333333333,
                                                    ys * Simd::<f64, N>::splat(0.3333333333333333),
                                                    z * 0.3333333333333333,
                                                )) * (Simd::<f32, N>::splat(3.0)));
                                            __below_mask.select(__below, __above)
                                        }
                                    };
                                    __below_mask.select(__below, __above)
                                }
                            };
                            __below_mask.select(__below, __above)
                        }
                    };
                    __below_mask.select(__below, __above)
                }
            }
        })
            .abs()) + (((__cse_34) * (Simd::<f32, N>::splat(0.083))))))
            .simd_max({
                let __v = (((((((Simd::<f32, N>::splat(cache.inline_noise_0))
                    * (Simd::<f32, N>::splat(8.0))))
                    + ({
                        let __coordinate = ys
                            .cast::<i32>()
                            .simd_max(Simd::splat(-64))
                            .simd_min(Simd::splat(320)) - Simd::splat(-64);
                        Simd::<f32, N>::splat(8.0)
                            + __coordinate.cast::<f32>()
                                * Simd::<f32, N>::splat((-40.0 - 8.0) / (320 - -64) as f32)
                    })))
                    .abs()) + (__cse_34));
                __v * __v * __v
            })
    })
        .simd_max(Simd::<f32, N>::splat(-1.0))
        .simd_min(Simd::<f32, N>::splat(1.0))
}
#[inline]
fn compute_overworld__depth_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    (({
        let __coordinate = ys
            .cast::<i32>()
            .simd_max(Simd::splat(-64))
            .simd_min(Simd::splat(320)) - Simd::splat(-64);
        Simd::<f32, N>::splat(1.5)
            + __coordinate.cast::<f32>()
                * Simd::<f32, N>::splat((-1.5 - 1.5) / (320 - -64) as f32)
    }) + (Simd::<f32, N>::splat(cache.df_overworld__offset)))
}
#[inline]
fn compute_overworld__sloped_cheese_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    (((({
        let __v = ((((compute_overworld__depth_simd::<N>(noises, cache, x, ys, z))
            + (((Simd::<f32, N>::splat(cache.df_overworld__jaggedness))
                * ({
                    let __v = Simd::<f32, N>::splat(cache.inline_noise_1);
                    let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                    __mask.select(__v, __v * Simd::<f32, N>::splat(0.5))
                }))))) * (Simd::<f32, N>::splat(cache.df_overworld__factor)));
        let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
        __mask.select(__v, __v * Simd::<f32, N>::splat(0.25))
    }) * (Simd::<f32, N>::splat(4.0))))
        + (compute_overworld__base_3d_noise_simd::<N>(noises, cache, x, ys, z)))
}
#[inline]
fn compute_overworld__final_density_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((({
        let __v = (({
            let __lerp_alpha = {
                let __coordinate = ys
                    .cast::<i32>()
                    .simd_max(Simd::splat(-64))
                    .simd_min(Simd::splat(-40)) - Simd::splat(-64);
                Simd::<f32, N>::splat(0.0)
                    + __coordinate.cast::<f32>()
                        * Simd::<f32, N>::splat((1.0 - 0.0) / (-40 - -64) as f32)
            };
            let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
            let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
            if __zero.all() {
                Simd::<f32, N>::splat(0.1171875)
            } else if __one.all() {
                {
                    let __lerp_alpha = {
                        let __coordinate = ys
                            .cast::<i32>()
                            .simd_max(Simd::splat(240))
                            .simd_min(Simd::splat(256)) - Simd::splat(240);
                        Simd::<f32, N>::splat(1.0)
                            + __coordinate.cast::<f32>()
                                * Simd::<f32, N>::splat((0.0 - 1.0) / (256 - 240) as f32)
                    };
                    let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
                    let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
                    if __zero.all() {
                        Simd::<f32, N>::splat(-0.078125)
                    } else if __one.all() {
                        {
                            let __branch_input_36 = compute_overworld__sloped_cheese_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __cse_37 = compute_overworld__caves__entrances_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __in_mask = __branch_input_36
                                .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                & __branch_input_36.simd_lt(Simd::<f32, N>::splat(1.5625));
                            if __in_mask.all() {
                                (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))))
                            } else if !__in_mask.any() {
                                ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    })
                            } else {
                                let __ir = (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))));
                                let __or = ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    });
                                __in_mask.select(__ir, __or)
                            }
                        }
                    } else {
                        let __lerp_first = Simd::<f32, N>::splat(-0.078125);
                        let __lerp_second = {
                            let __branch_input_36 = compute_overworld__sloped_cheese_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __cse_37 = compute_overworld__caves__entrances_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __in_mask = __branch_input_36
                                .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                & __branch_input_36.simd_lt(Simd::<f32, N>::splat(1.5625));
                            if __in_mask.all() {
                                (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))))
                            } else if !__in_mask.any() {
                                ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    })
                            } else {
                                let __ir = (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))));
                                let __or = ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    });
                                __in_mask.select(__ir, __or)
                            }
                        };
                        let __lerp_value = __lerp_first
                            + __lerp_alpha * (__lerp_second - __lerp_first);
                        __zero
                            .select(
                                __lerp_first,
                                __one.select(__lerp_second, __lerp_value),
                            )
                    }
                }
            } else {
                let __lerp_first = Simd::<f32, N>::splat(0.1171875);
                let __lerp_second = {
                    let __lerp_alpha = {
                        let __coordinate = ys
                            .cast::<i32>()
                            .simd_max(Simd::splat(240))
                            .simd_min(Simd::splat(256)) - Simd::splat(240);
                        Simd::<f32, N>::splat(1.0)
                            + __coordinate.cast::<f32>()
                                * Simd::<f32, N>::splat((0.0 - 1.0) / (256 - 240) as f32)
                    };
                    let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
                    let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
                    if __zero.all() {
                        Simd::<f32, N>::splat(-0.078125)
                    } else if __one.all() {
                        {
                            let __branch_input_36 = compute_overworld__sloped_cheese_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __cse_37 = compute_overworld__caves__entrances_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __in_mask = __branch_input_36
                                .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                & __branch_input_36.simd_lt(Simd::<f32, N>::splat(1.5625));
                            if __in_mask.all() {
                                (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))))
                            } else if !__in_mask.any() {
                                ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    })
                            } else {
                                let __ir = (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))));
                                let __or = ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    });
                                __in_mask.select(__ir, __or)
                            }
                        }
                    } else {
                        let __lerp_first = Simd::<f32, N>::splat(-0.078125);
                        let __lerp_second = {
                            let __branch_input_36 = compute_overworld__sloped_cheese_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __cse_37 = compute_overworld__caves__entrances_simd::<
                                N,
                            >(noises, cache, x, ys, z);
                            let __in_mask = __branch_input_36
                                .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                & __branch_input_36.simd_lt(Simd::<f32, N>::splat(1.5625));
                            if __in_mask.all() {
                                (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))))
                            } else if !__in_mask.any() {
                                ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    })
                            } else {
                                let __ir = (__branch_input_36)
                                    .simd_min(((__cse_37) * (Simd::<f32, N>::splat(5.0))));
                                let __or = ((((((({
                                    let __v = noises
                                        .n_cave_layer
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(8.0),
                                            z * 1.0,
                                        );
                                    __v * __v
                                }) * (Simd::<f32, N>::splat(4.0))))
                                    + ((((((noises
                                        .n_cave_cheese
                                        .get_value_y_simd(
                                            x * 1.0,
                                            ys * Simd::<f64, N>::splat(0.6666666666666666),
                                            z * 1.0,
                                        )) + (Simd::<f32, N>::splat(0.27))))
                                        .simd_max(Simd::<f32, N>::splat(-1.0))
                                        .simd_min(Simd::<f32, N>::splat(1.0)))
                                        + ((((((__branch_input_36)
                                            * (Simd::<f32, N>::splat(-0.64))))
                                            + (Simd::<f32, N>::splat(1.5))))
                                            .simd_max(Simd::<f32, N>::splat(0.0))
                                            .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                    .simd_min(__cse_37))
                                    .simd_min(
                                        ((compute_overworld__caves__spaghetti_2d_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))
                                            + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                                N,
                                            >(noises, cache, x, ys, z))),
                                    ))
                                    .simd_max({
                                        let __branch_input_38 = compute_overworld__caves__pillars_simd::<
                                            N,
                                        >(noises, cache, x, ys, z);
                                        let __in_mask = __branch_input_38
                                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                            & __branch_input_38.simd_lt(Simd::<f32, N>::splat(0.03));
                                        if __in_mask.all() {
                                            Simd::<f32, N>::splat(-1000000.0)
                                        } else if !__in_mask.any() {
                                            __branch_input_38
                                        } else {
                                            let __ir = Simd::<f32, N>::splat(-1000000.0);
                                            let __or = __branch_input_38;
                                            __in_mask.select(__ir, __or)
                                        }
                                    });
                                __in_mask.select(__ir, __or)
                            }
                        };
                        let __lerp_value = __lerp_first
                            + __lerp_alpha * (__lerp_second - __lerp_first);
                        __zero
                            .select(
                                __lerp_first,
                                __one.select(__lerp_second, __lerp_value),
                            )
                    }
                };
                let __lerp_value = __lerp_first
                    + __lerp_alpha * (__lerp_second - __lerp_first);
                __zero.select(__lerp_first, __one.select(__lerp_second, __lerp_value))
            }
        }) * (Simd::<f32, N>::splat(0.64)));
        let __c = __v
            .simd_max(Simd::<f32, N>::splat(-1.0))
            .simd_min(Simd::<f32, N>::splat(1.0));
        __c / Simd::<f32, N>::splat(2.0) - __c * __c * __c / Simd::<f32, N>::splat(24.0)
    })
        .simd_min(compute_overworld__caves__noodle_simd::<N>(noises, cache, x, ys, z)))
        + (Simd::<f32, N>::splat(0.0)))
}
#[inline]
fn compute_overworld__ore_vein__toggle_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __branch_input_39 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_39.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_39.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    }
}
#[inline]
fn compute_overworld__ore_vein__mask_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __branch_input_40 = compute_overworld__ore_vein__toggle_simd::<
            N,
        >(noises, cache, x, ys, z);
        let __in_mask = __branch_input_40.simd_ge(Simd::<f32, N>::splat(-0.4))
            & __branch_input_40.simd_lt(Simd::<f32, N>::splat(0.4));
        if __in_mask.all() {
            Simd::<f32, N>::splat(-1.0)
        } else if !__in_mask.any() {
            ((Simd::<f32, N>::splat(0.08))
                - ({
                    let __cse_41 = compute_y_simd::<N>(noises, cache, x, ys, z);
                    (({
                        let __branch_input_42 = __cse_41;
                        let __in_mask = __branch_input_42
                            .simd_ge(Simd::<f32, N>::splat(-64.0))
                            & __branch_input_42.simd_lt(Simd::<f32, N>::splat(57.0));
                        if __in_mask.all() {
                            noises
                                .n_ore_vein_a
                                .get_value_y_simd(
                                    x * 4.0,
                                    ys * Simd::<f64, N>::splat(4.0),
                                    z * 4.0,
                                )
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(1.0)
                        } else {
                            let __ir = noises
                                .n_ore_vein_a
                                .get_value_y_simd(
                                    x * 4.0,
                                    ys * Simd::<f64, N>::splat(4.0),
                                    z * 4.0,
                                );
                            let __or = Simd::<f32, N>::splat(1.0);
                            __in_mask.select(__ir, __or)
                        }
                    })
                        .abs())
                        .simd_max(
                            ({
                                let __branch_input_43 = __cse_41;
                                let __in_mask = __branch_input_43
                                    .simd_ge(Simd::<f32, N>::splat(-64.0))
                                    & __branch_input_43.simd_lt(Simd::<f32, N>::splat(57.0));
                                if __in_mask.all() {
                                    noises
                                        .n_ore_vein_b
                                        .get_value_y_simd(
                                            x * 4.0,
                                            ys * Simd::<f64, N>::splat(4.0),
                                            z * 4.0,
                                        )
                                } else if !__in_mask.any() {
                                    Simd::<f32, N>::splat(1.0)
                                } else {
                                    let __ir = noises
                                        .n_ore_vein_b
                                        .get_value_y_simd(
                                            x * 4.0,
                                            ys * Simd::<f64, N>::splat(4.0),
                                            z * 4.0,
                                        );
                                    let __or = Simd::<f32, N>::splat(1.0);
                                    __in_mask.select(__ir, __or)
                                }
                            })
                                .abs(),
                        )
                }))
        } else {
            let __ir = Simd::<f32, N>::splat(-1.0);
            let __or = ((Simd::<f32, N>::splat(0.08))
                - ({
                    let __cse_41 = compute_y_simd::<N>(noises, cache, x, ys, z);
                    (({
                        let __branch_input_42 = __cse_41;
                        let __in_mask = __branch_input_42
                            .simd_ge(Simd::<f32, N>::splat(-64.0))
                            & __branch_input_42.simd_lt(Simd::<f32, N>::splat(57.0));
                        if __in_mask.all() {
                            noises
                                .n_ore_vein_a
                                .get_value_y_simd(
                                    x * 4.0,
                                    ys * Simd::<f64, N>::splat(4.0),
                                    z * 4.0,
                                )
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(1.0)
                        } else {
                            let __ir = noises
                                .n_ore_vein_a
                                .get_value_y_simd(
                                    x * 4.0,
                                    ys * Simd::<f64, N>::splat(4.0),
                                    z * 4.0,
                                );
                            let __or = Simd::<f32, N>::splat(1.0);
                            __in_mask.select(__ir, __or)
                        }
                    })
                        .abs())
                        .simd_max(
                            ({
                                let __branch_input_43 = __cse_41;
                                let __in_mask = __branch_input_43
                                    .simd_ge(Simd::<f32, N>::splat(-64.0))
                                    & __branch_input_43.simd_lt(Simd::<f32, N>::splat(57.0));
                                if __in_mask.all() {
                                    noises
                                        .n_ore_vein_b
                                        .get_value_y_simd(
                                            x * 4.0,
                                            ys * Simd::<f64, N>::splat(4.0),
                                            z * 4.0,
                                        )
                                } else if !__in_mask.any() {
                                    Simd::<f32, N>::splat(1.0)
                                } else {
                                    let __ir = noises
                                        .n_ore_vein_b
                                        .get_value_y_simd(
                                            x * 4.0,
                                            ys * Simd::<f64, N>::splat(4.0),
                                            z * 4.0,
                                        );
                                    let __or = Simd::<f32, N>::splat(1.0);
                                    __in_mask.select(__ir, __or)
                                }
                            })
                                .abs(),
                        )
                }));
            __in_mask.select(__ir, __or)
        }
    }
}
#[inline]
fn compute_overworld__ore_vein__copper_density_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __branch_input_44 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_44.simd_ge(Simd::<f32, N>::splat(0.0))
            & __branch_input_44.simd_lt(Simd::<f32, N>::splat(50.0));
        if __in_mask.all() {
            {
                let __branch_input_45 = compute_overworld__ore_vein__mask_simd::<
                    N,
                >(noises, cache, x, ys, z);
                let __in_mask = __branch_input_45.simd_ge(Simd::<f32, N>::splat(0.0))
                    & __branch_input_45.simd_lt(Simd::<f32, N>::splat(1000000.0));
                if __in_mask.all() {
                    {
                        let __branch_input_46 = ((((compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(50.0))
                                    - (__branch_input_44));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4064.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_44) - (Simd::<f32, N>::splat(0.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_46
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_46
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else if !__in_mask.any() {
                    Simd::<f32, N>::splat(-1.0)
                } else {
                    let __ir = {
                        let __branch_input_46 = ((((compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(50.0))
                                    - (__branch_input_44));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4064.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_44) - (Simd::<f32, N>::splat(0.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_46
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_46
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __or = Simd::<f32, N>::splat(-1.0);
                    __in_mask.select(__ir, __or)
                }
            }
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(-1.0)
        } else {
            let __ir = {
                let __branch_input_45 = compute_overworld__ore_vein__mask_simd::<
                    N,
                >(noises, cache, x, ys, z);
                let __in_mask = __branch_input_45.simd_ge(Simd::<f32, N>::splat(0.0))
                    & __branch_input_45.simd_lt(Simd::<f32, N>::splat(1000000.0));
                if __in_mask.all() {
                    {
                        let __branch_input_46 = ((((compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(50.0))
                                    - (__branch_input_44));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4064.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_44) - (Simd::<f32, N>::splat(0.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_46
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_46
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else if !__in_mask.any() {
                    Simd::<f32, N>::splat(-1.0)
                } else {
                    let __ir = {
                        let __branch_input_46 = ((((compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(50.0))
                                    - (__branch_input_44));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4064.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_44) - (Simd::<f32, N>::splat(0.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_46
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_46
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __or = Simd::<f32, N>::splat(-1.0);
                    __in_mask.select(__ir, __or)
                }
            };
            let __or = Simd::<f32, N>::splat(-1.0);
            __in_mask.select(__ir, __or)
        }
    }
}
#[inline]
fn compute_overworld__ore_vein__gap_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((Simd::<f32, N>::splat(-0.3))
        - (noises
            .n_ore_gap
            .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0)))
}
#[inline]
fn compute_overworld__ore_vein__iron_density_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    {
        let __branch_input_47 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_47.simd_ge(Simd::<f32, N>::splat(-60.0))
            & __branch_input_47.simd_lt(Simd::<f32, N>::splat(-8.0));
        if __in_mask.all() {
            {
                let __branch_input_48 = compute_overworld__ore_vein__mask_simd::<
                    N,
                >(noises, cache, x, ys, z);
                let __in_mask = __branch_input_48.simd_ge(Simd::<f32, N>::splat(0.0))
                    & __branch_input_48.simd_lt(Simd::<f32, N>::splat(1000000.0));
                if __in_mask.all() {
                    {
                        let __branch_input_49 = (((((-(compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)))) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(-8.0))
                                    - (__branch_input_47));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4004.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_47) - (Simd::<f32, N>::splat(-60.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_49
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_49
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else if !__in_mask.any() {
                    Simd::<f32, N>::splat(-1.0)
                } else {
                    let __ir = {
                        let __branch_input_49 = (((((-(compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)))) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(-8.0))
                                    - (__branch_input_47));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4004.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_47) - (Simd::<f32, N>::splat(-60.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_49
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_49
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __or = Simd::<f32, N>::splat(-1.0);
                    __in_mask.select(__ir, __or)
                }
            }
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(-1.0)
        } else {
            let __ir = {
                let __branch_input_48 = compute_overworld__ore_vein__mask_simd::<
                    N,
                >(noises, cache, x, ys, z);
                let __in_mask = __branch_input_48.simd_ge(Simd::<f32, N>::splat(0.0))
                    & __branch_input_48.simd_lt(Simd::<f32, N>::splat(1000000.0));
                if __in_mask.all() {
                    {
                        let __branch_input_49 = (((((-(compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)))) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(-8.0))
                                    - (__branch_input_47));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4004.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_47) - (Simd::<f32, N>::splat(-60.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_49
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_49
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else if !__in_mask.any() {
                    Simd::<f32, N>::splat(-1.0)
                } else {
                    let __ir = {
                        let __branch_input_49 = (((((-(compute_overworld__ore_vein__toggle_simd::<
                            N,
                        >(noises, cache, x, ys, z)))) - (Simd::<f32, N>::splat(0.4))))
                            + (((((({
                                let __sc_a = ((Simd::<f32, N>::splat(-8.0))
                                    - (__branch_input_47));
                                if __sc_a.simd_le(Simd::<f32, N>::splat(-4004.0)).all() {
                                    __sc_a
                                } else {
                                    __sc_a
                                        .simd_min(
                                            ((__branch_input_47) - (Simd::<f32, N>::splat(-60.0))),
                                        )
                                }
                            })
                                .simd_max(Simd::<f32, N>::splat(0.0))
                                .simd_min(Simd::<f32, N>::splat(20.0)))
                                * (Simd::<f32, N>::splat(0.01))))
                                + (Simd::<f32, N>::splat(-0.2)))));
                        let __in_mask = __branch_input_49
                            .simd_ge(Simd::<f32, N>::splat(0.0))
                            & __branch_input_49
                                .simd_lt(Simd::<f32, N>::splat(1000000.0));
                        if __in_mask.all() {
                            Simd::<f32, N>::splat(0.7)
                        } else if !__in_mask.any() {
                            Simd::<f32, N>::splat(-1.0)
                        } else {
                            let __ir = Simd::<f32, N>::splat(0.7);
                            let __or = Simd::<f32, N>::splat(-1.0);
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __or = Simd::<f32, N>::splat(-1.0);
                    __in_mask.select(__ir, __or)
                }
            };
            let __or = Simd::<f32, N>::splat(-1.0);
            __in_mask.select(__ir, __or)
        }
    }
}
#[inline]
fn compute_overworld__ore_vein__richness_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    ys: Simd<f64, N>,
    z: f64,
) -> Simd<f32, N> {
    ((((((compute_overworld__ore_vein__toggle_simd::<N>(noises, cache, x, ys, z)).abs())
        .simd_max(Simd::<f32, N>::splat(0.4))
        .simd_min(Simd::<f32, N>::splat(0.6))) * (Simd::<f32, N>::splat(1.0))))
        + (Simd::<f32, N>::splat(-0.3)))
}
/// Whether any aquifer router needs prepared column values.
pub const AQUIFER_NEEDS_COLUMN_CACHE: bool = false;
///Noise router entry: `barrier`
#[inline]
pub fn router_barrier(
    noises: &OverworldNoises,
    _cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (noises.n_aquifer_barrier.get_value(x * 1.0, y * 0.5, z * 1.0)) as f32
}
#[inline]
fn compute_router_continentalness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__continents) as f32
}
///Noise router entry: `continentalness`
#[inline]
pub fn router_continentalness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_continentalness
}
///Noise router entry: `depth`
#[inline]
pub fn router_depth(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__depth(noises, cache, x, y, z)) as f32
}
#[inline]
fn compute_router_erosion(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__erosion) as f32
}
///Noise router entry: `erosion`
#[inline]
pub fn router_erosion(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_erosion
}
///Noise router entry: `final_density`
#[inline]
pub fn router_final_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__final_density(noises, cache, x, y, z)) as f32
}
///Noise router entry: `fluid_level_floodedness`
#[inline]
pub fn router_fluid_level_floodedness(
    noises: &OverworldNoises,
    _cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (noises.n_aquifer_fluid_level_floodedness.get_value(x * 1.0, y * 0.67, z * 1.0))
        as f32
}
///Noise router entry: `fluid_level_spread`
#[inline]
pub fn router_fluid_level_spread(
    noises: &OverworldNoises,
    _cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (noises
        .n_aquifer_fluid_level_spread
        .get_value(x * 1.0, y * 0.7142857142857143, z * 1.0)) as f32
}
///Noise router entry: `lava`
#[inline]
pub fn router_lava(
    noises: &OverworldNoises,
    _cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    (noises.n_aquifer_lava.get_value(x * 1.0, y * 1.0, z * 1.0)) as f32
}
///Noise router entry: `material_ore_vein_0_density`
#[inline]
pub fn router_material_ore_vein_0_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__copper_density(noises, cache, x, y, z)) as f32
}
///Noise router entry: `material_ore_vein_0_filler_gap`
#[inline]
pub fn router_material_ore_vein_0_filler_gap(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__gap(noises, cache, x, y, z)) as f32
}
///Noise router entry: `material_ore_vein_0_richness`
#[inline]
pub fn router_material_ore_vein_0_richness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__richness(noises, cache, x, y, z)) as f32
}
///Noise router entry: `material_ore_vein_1_density`
#[inline]
pub fn router_material_ore_vein_1_density(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__iron_density(noises, cache, x, y, z)) as f32
}
///Noise router entry: `material_ore_vein_1_filler_gap`
#[inline]
pub fn router_material_ore_vein_1_filler_gap(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__gap(noises, cache, x, y, z)) as f32
}
///Noise router entry: `material_ore_vein_1_richness`
#[inline]
pub fn router_material_ore_vein_1_richness(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    (compute_overworld__ore_vein__richness(noises, cache, x, y, z)) as f32
}
#[inline]
fn compute_router_preliminary_surface_level(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__preliminary_surface_level) as f32
}
///Noise router entry: `preliminary_surface_level`
#[inline]
pub fn router_preliminary_surface_level(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_preliminary_surface_level
}
#[inline]
fn compute_router_ridges(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__ridges) as f32
}
///Noise router entry: `ridges`
#[inline]
pub fn router_ridges(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_ridges
}
#[inline]
fn compute_router_temperature(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__temperature) as f32
}
///Noise router entry: `temperature`
#[inline]
pub fn router_temperature(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_temperature
}
#[inline]
fn compute_router_vegetation(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    z: f64,
) -> f32 {
    (cache.df_overworld__vegetation) as f32
}
///Noise router entry: `vegetation`
#[inline]
pub fn router_vegetation(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: f64,
    y: f64,
    z: f64,
) -> f32 {
    cache.router_vegetation
}
/// Total number of independently interpolated channels across all
/// router entries (final_density + vein_toggle + vein_ridged).
pub const INTERPOLATED_COUNT: usize = 15;
/// Whether vein functions have interpolation channels.
pub const VEIN_INTERP_ENABLED: bool = false;
/// Channels that, when `<= 0` at a block, prove its combined final
/// density is not positive. Check actual interpolated block values.
pub const FINAL_DENSITY_NONPOSITIVE_CHANNELS: Option<&[usize]> = Some(&[0]);
/// Evaluate the inner functions of all `Interpolated` markers at a cell corner.
///
/// `out` must have length `INTERPOLATED_COUNT`.
#[expect(
    unused_variables,
    reason = "generated function has a fixed signature; blended_noise_value is unused in dimensions without blended noise"
)]
pub fn fill_cell_corner_densities(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: i32,
    y: i32,
    z: i32,
    blended_noise_value: f32,
    out: &mut [f32],
) {
    let x = cache.x as f64;
    let z = cache.z as f64;
    let y = y as f64;
    out[0] = ((((({
        let __lerp_alpha = ({
            let __coordinate = (y as i32).clamp(-64, -40) - -64;
            0.0 + __coordinate as f32 * ((1.0 - 0.0) / (-40 - -64) as f32)
        }) as f32;
        if __lerp_alpha == 0.0 {
            (0.1171875) as f32
        } else if __lerp_alpha == 1.0 {
            ({
                let __lerp_alpha = ({
                    let __coordinate = (y as i32).clamp(240, 256) - 240;
                    1.0 + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                }) as f32;
                if __lerp_alpha == 0.0 {
                    (-0.078125) as f32
                } else if __lerp_alpha == 1.0 {
                    ({
                        let __branch_input_50 = ((((((((({
                            let v = (((((((compute_overworld__depth(
                                noises,
                                cache,
                                x,
                                y,
                                z,
                            )) as f32)
                                + ((((((cache.df_overworld__jaggedness) as f32)
                                    * (({
                                        let v = cache.inline_noise_1;
                                        if v > 0.0 { v } else { v * 0.5 }
                                    }) as f32))) as f32) as f32))) as f32)
                                * ((cache.df_overworld__factor) as f32))) as f32;
                            if v > 0.0 { v } else { v * 0.25 }
                        }) as f32) * ((4.0) as f32))) as f32)
                            + (((blended_noise_value as f32) as f32) as f32))) as f32)
                            as f32) as f32;
                        let __cse_51 = (compute_overworld__caves__entrances(
                            noises,
                            cache,
                            x,
                            y,
                            z,
                        )) as f32;
                        if __branch_input_50 >= -1000000.0 && __branch_input_50 < 1.5625
                        {
                            ({
                                let __sc_a = __branch_input_50;
                                let __sc_b = (((__cse_51) * ((5.0) as f32))) as f32;
                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                            }) as f32
                        } else {
                            ({
                                let __sc_a = ({
                                    let __sc_a = ({
                                        let __sc_a = ((((((({
                                            let v = (noises
                                                .n_cave_layer
                                                .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                            v * v
                                        }) as f32) * ((4.0) as f32))) as f32)
                                            + ((((((((((noises
                                                .n_cave_cheese
                                                .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                as f32) + ((0.27) as f32))) as f32)
                                                .clamp(-1.0, 1.0)) as f32)
                                                + (((((((((__branch_input_50) * ((-0.64) as f32))) as f32)
                                                    + ((1.5) as f32))) as f32)
                                                    .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                        let __sc_b = __cse_51;
                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                    }) as f32;
                                    let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                        noises,
                                        cache,
                                        x,
                                        y,
                                        z,
                                    )) as f32)
                                        + ((compute_overworld__caves__spaghetti_roughness_function(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32))) as f32;
                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                }) as f32;
                                let __sc_b = ({
                                    let __branch_input_52 = (compute_overworld__caves__pillars(
                                        noises,
                                        cache,
                                        x,
                                        y,
                                        z,
                                    )) as f32;
                                    if __branch_input_52 >= -1000000.0
                                        && __branch_input_52 < 0.03
                                    {
                                        (-1000000.0) as f32
                                    } else {
                                        __branch_input_52
                                    }
                                }) as f32;
                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                            }) as f32
                        }
                    }) as f32
                } else {
                    let __lerp_first = (-0.078125) as f32;
                    __lerp_first
                        + __lerp_alpha
                            * ((({
                                let __branch_input_50 = ((((((((({
                                    let v = (((((((compute_overworld__depth(
                                        noises,
                                        cache,
                                        x,
                                        y,
                                        z,
                                    )) as f32)
                                        + ((((((cache.df_overworld__jaggedness) as f32)
                                            * (({
                                                let v = cache.inline_noise_1;
                                                if v > 0.0 { v } else { v * 0.5 }
                                            }) as f32))) as f32) as f32))) as f32)
                                        * ((cache.df_overworld__factor) as f32))) as f32;
                                    if v > 0.0 { v } else { v * 0.25 }
                                }) as f32) * ((4.0) as f32))) as f32)
                                    + (((blended_noise_value as f32) as f32) as f32))) as f32)
                                    as f32) as f32;
                                let __cse_51 = (compute_overworld__caves__entrances(
                                    noises,
                                    cache,
                                    x,
                                    y,
                                    z,
                                )) as f32;
                                if __branch_input_50 >= -1000000.0
                                    && __branch_input_50 < 1.5625
                                {
                                    ({
                                        let __sc_a = __branch_input_50;
                                        let __sc_b = (((__cse_51) * ((5.0) as f32))) as f32;
                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                } else {
                                    ({
                                        let __sc_a = ({
                                            let __sc_a = ({
                                                let __sc_a = ((((((({
                                                    let v = (noises
                                                        .n_cave_layer
                                                        .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                    v * v
                                                }) as f32) * ((4.0) as f32))) as f32)
                                                    + ((((((((((noises
                                                        .n_cave_cheese
                                                        .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                        as f32) + ((0.27) as f32))) as f32)
                                                        .clamp(-1.0, 1.0)) as f32)
                                                        + (((((((((__branch_input_50) * ((-0.64) as f32))) as f32)
                                                            + ((1.5) as f32))) as f32)
                                                            .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                let __sc_b = __cse_51;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32;
                                            let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32)
                                                + ((compute_overworld__caves__spaghetti_roughness_function(
                                                    noises,
                                                    cache,
                                                    x,
                                                    y,
                                                    z,
                                                )) as f32))) as f32;
                                            if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                        }) as f32;
                                        let __sc_b = ({
                                            let __branch_input_52 = (compute_overworld__caves__pillars(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32;
                                            if __branch_input_52 >= -1000000.0
                                                && __branch_input_52 < 0.03
                                            {
                                                (-1000000.0) as f32
                                            } else {
                                                __branch_input_52
                                            }
                                        }) as f32;
                                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                }
                            }) as f32) - __lerp_first)
                }
            }) as f32
        } else {
            let __lerp_first = (0.1171875) as f32;
            __lerp_first
                + __lerp_alpha
                    * ((({
                        let __lerp_alpha = ({
                            let __coordinate = (y as i32).clamp(240, 256) - 240;
                            1.0
                                + __coordinate as f32 * ((0.0 - 1.0) / (256 - 240) as f32)
                        }) as f32;
                        if __lerp_alpha == 0.0 {
                            (-0.078125) as f32
                        } else if __lerp_alpha == 1.0 {
                            ({
                                let __branch_input_50 = ((((((((({
                                    let v = (((((((compute_overworld__depth(
                                        noises,
                                        cache,
                                        x,
                                        y,
                                        z,
                                    )) as f32)
                                        + ((((((cache.df_overworld__jaggedness) as f32)
                                            * (({
                                                let v = cache.inline_noise_1;
                                                if v > 0.0 { v } else { v * 0.5 }
                                            }) as f32))) as f32) as f32))) as f32)
                                        * ((cache.df_overworld__factor) as f32))) as f32;
                                    if v > 0.0 { v } else { v * 0.25 }
                                }) as f32) * ((4.0) as f32))) as f32)
                                    + (((blended_noise_value as f32) as f32) as f32))) as f32)
                                    as f32) as f32;
                                let __cse_51 = (compute_overworld__caves__entrances(
                                    noises,
                                    cache,
                                    x,
                                    y,
                                    z,
                                )) as f32;
                                if __branch_input_50 >= -1000000.0
                                    && __branch_input_50 < 1.5625
                                {
                                    ({
                                        let __sc_a = __branch_input_50;
                                        let __sc_b = (((__cse_51) * ((5.0) as f32))) as f32;
                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                } else {
                                    ({
                                        let __sc_a = ({
                                            let __sc_a = ({
                                                let __sc_a = ((((((({
                                                    let v = (noises
                                                        .n_cave_layer
                                                        .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                    v * v
                                                }) as f32) * ((4.0) as f32))) as f32)
                                                    + ((((((((((noises
                                                        .n_cave_cheese
                                                        .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                        as f32) + ((0.27) as f32))) as f32)
                                                        .clamp(-1.0, 1.0)) as f32)
                                                        + (((((((((__branch_input_50) * ((-0.64) as f32))) as f32)
                                                            + ((1.5) as f32))) as f32)
                                                            .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                let __sc_b = __cse_51;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32;
                                            let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32)
                                                + ((compute_overworld__caves__spaghetti_roughness_function(
                                                    noises,
                                                    cache,
                                                    x,
                                                    y,
                                                    z,
                                                )) as f32))) as f32;
                                            if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                        }) as f32;
                                        let __sc_b = ({
                                            let __branch_input_52 = (compute_overworld__caves__pillars(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32;
                                            if __branch_input_52 >= -1000000.0
                                                && __branch_input_52 < 0.03
                                            {
                                                (-1000000.0) as f32
                                            } else {
                                                __branch_input_52
                                            }
                                        }) as f32;
                                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                    }) as f32
                                }
                            }) as f32
                        } else {
                            let __lerp_first = (-0.078125) as f32;
                            __lerp_first
                                + __lerp_alpha
                                    * ((({
                                        let __branch_input_50 = ((((((((({
                                            let v = (((((((compute_overworld__depth(
                                                noises,
                                                cache,
                                                x,
                                                y,
                                                z,
                                            )) as f32)
                                                + ((((((cache.df_overworld__jaggedness) as f32)
                                                    * (({
                                                        let v = cache.inline_noise_1;
                                                        if v > 0.0 { v } else { v * 0.5 }
                                                    }) as f32))) as f32) as f32))) as f32)
                                                * ((cache.df_overworld__factor) as f32))) as f32;
                                            if v > 0.0 { v } else { v * 0.25 }
                                        }) as f32) * ((4.0) as f32))) as f32)
                                            + (((blended_noise_value as f32) as f32) as f32))) as f32)
                                            as f32) as f32;
                                        let __cse_51 = (compute_overworld__caves__entrances(
                                            noises,
                                            cache,
                                            x,
                                            y,
                                            z,
                                        )) as f32;
                                        if __branch_input_50 >= -1000000.0
                                            && __branch_input_50 < 1.5625
                                        {
                                            ({
                                                let __sc_a = __branch_input_50;
                                                let __sc_b = (((__cse_51) * ((5.0) as f32))) as f32;
                                                if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        } else {
                                            ({
                                                let __sc_a = ({
                                                    let __sc_a = ({
                                                        let __sc_a = ((((((({
                                                            let v = (noises
                                                                .n_cave_layer
                                                                .get_value(x * 1.0, y * 8.0, z * 1.0)) as f32;
                                                            v * v
                                                        }) as f32) * ((4.0) as f32))) as f32)
                                                            + ((((((((((noises
                                                                .n_cave_cheese
                                                                .get_value(x * 1.0, y * 0.6666666666666666, z * 1.0))
                                                                as f32) + ((0.27) as f32))) as f32)
                                                                .clamp(-1.0, 1.0)) as f32)
                                                                + (((((((((__branch_input_50) * ((-0.64) as f32))) as f32)
                                                                    + ((1.5) as f32))) as f32)
                                                                    .clamp(0.0, 0.5)) as f32))) as f32))) as f32;
                                                        let __sc_b = __cse_51;
                                                        if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                    }) as f32;
                                                    let __sc_b = ((((compute_overworld__caves__spaghetti_2d(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32)
                                                        + ((compute_overworld__caves__spaghetti_roughness_function(
                                                            noises,
                                                            cache,
                                                            x,
                                                            y,
                                                            z,
                                                        )) as f32))) as f32;
                                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                                }) as f32;
                                                let __sc_b = ({
                                                    let __branch_input_52 = (compute_overworld__caves__pillars(
                                                        noises,
                                                        cache,
                                                        x,
                                                        y,
                                                        z,
                                                    )) as f32;
                                                    if __branch_input_52 >= -1000000.0
                                                        && __branch_input_52 < 0.03
                                                    {
                                                        (-1000000.0) as f32
                                                    } else {
                                                        __branch_input_52
                                                    }
                                                }) as f32;
                                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                                            }) as f32
                                        }
                                    }) as f32) - __lerp_first)
                        }
                    }) as f32) - __lerp_first)
        }
    }) as f32) as f32) * ((0.64) as f32))) as f32;
    out[1] = ({
        let __branch_input_53 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_53 >= -60.0 && __branch_input_53 < 321.0 {
            (noises.n_noodle.get_value(x * 1.0, y * 1.0, z * 1.0)) as f32
        } else {
            (-1.0) as f32
        }
    }) as f32;
    out[2] = ({
        let __branch_input_54 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_54 >= -60.0 && __branch_input_54 < 321.0 {
            (((((((noises.n_noodle_thickness.get_value(x * 1.0, y * 1.0, z * 1.0))
                as f32) * ((-0.025) as f32))) as f32) + ((-0.075) as f32))) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[3] = ({
        let __branch_input_55 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_55 >= -60.0 && __branch_input_55 < 321.0 {
            (noises
                .n_noodle_ridge_a
                .get_value(
                    x * 2.6666666666666665,
                    y * 2.6666666666666665,
                    z * 2.6666666666666665,
                )) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[4] = ({
        let __branch_input_56 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_56 >= -60.0 && __branch_input_56 < 321.0 {
            (noises
                .n_noodle_ridge_b
                .get_value(
                    x * 2.6666666666666665,
                    y * 2.6666666666666665,
                    z * 2.6666666666666665,
                )) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[5] = ({
        let __branch_input_57 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_57 >= -64.0 && __branch_input_57 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[6] = ({
        let __branch_input_58 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_58 >= -64.0 && __branch_input_58 < 57.0 {
            (noises.n_ore_vein_a.get_value(x * 4.0, y * 4.0, z * 4.0)) as f32
        } else {
            (1.0) as f32
        }
    }) as f32;
    out[7] = ({
        let __branch_input_59 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_59 >= -64.0 && __branch_input_59 < 57.0 {
            (noises.n_ore_vein_b.get_value(x * 4.0, y * 4.0, z * 4.0)) as f32
        } else {
            (1.0) as f32
        }
    }) as f32;
    out[8] = ({
        let __branch_input_60 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_60 >= -64.0 && __branch_input_60 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[9] = ({
        let __branch_input_61 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_61 >= -64.0 && __branch_input_61 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[10] = ({
        let __branch_input_62 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_62 >= -64.0 && __branch_input_62 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[11] = ({
        let __branch_input_63 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_63 >= -64.0 && __branch_input_63 < 57.0 {
            (noises.n_ore_vein_a.get_value(x * 4.0, y * 4.0, z * 4.0)) as f32
        } else {
            (1.0) as f32
        }
    }) as f32;
    out[12] = ({
        let __branch_input_64 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_64 >= -64.0 && __branch_input_64 < 57.0 {
            (noises.n_ore_vein_b.get_value(x * 4.0, y * 4.0, z * 4.0)) as f32
        } else {
            (1.0) as f32
        }
    }) as f32;
    out[13] = ({
        let __branch_input_65 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_65 >= -64.0 && __branch_input_65 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
    out[14] = ({
        let __branch_input_66 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_66 >= -64.0 && __branch_input_66 < 57.0 {
            (noises.n_ore_veininess.get_value(x * 1.5, y * 1.5, z * 1.5)) as f32
        } else {
            (0.0) as f32
        }
    }) as f32;
}
/// SIMD form of [`fill_cell_corner_densities`] with a generic
/// compile-time batch width.
#[inline]
pub fn fill_cell_corner_densities_y_simd<const N: usize>(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    x: i32,
    ys: [i32; N],
    z: i32,
    blended_noise_values: [f32; N],
    out: &mut [f32],
) {
    let x = cache.x as f64;
    let z = cache.z as f64;
    let ys = Simd::from_array(ys.map(f64::from));
    let blended_noise_value_v = Simd::from_array(blended_noise_values);
    let __values_simd_0 = ((({
        let __lerp_alpha = {
            let __coordinate = ys
                .cast::<i32>()
                .simd_max(Simd::splat(-64))
                .simd_min(Simd::splat(-40)) - Simd::splat(-64);
            Simd::<f32, N>::splat(0.0)
                + __coordinate.cast::<f32>()
                    * Simd::<f32, N>::splat((1.0 - 0.0) / (-40 - -64) as f32)
        };
        let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
        let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
        if __zero.all() {
            Simd::<f32, N>::splat(0.1171875)
        } else if __one.all() {
            {
                let __lerp_alpha = {
                    let __coordinate = ys
                        .cast::<i32>()
                        .simd_max(Simd::splat(240))
                        .simd_min(Simd::splat(256)) - Simd::splat(240);
                    Simd::<f32, N>::splat(1.0)
                        + __coordinate.cast::<f32>()
                            * Simd::<f32, N>::splat((0.0 - 1.0) / (256 - 240) as f32)
                };
                let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
                let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
                if __zero.all() {
                    Simd::<f32, N>::splat(-0.078125)
                } else if __one.all() {
                    {
                        let __branch_input_67 = (((({
                            let __v = ((((compute_overworld__depth_simd::<
                                N,
                            >(noises, cache, x, ys, z))
                                + (((Simd::<f32, N>::splat(cache.df_overworld__jaggedness))
                                    * ({
                                        let __v = Simd::<f32, N>::splat(cache.inline_noise_1);
                                        let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                                        __mask.select(__v, __v * Simd::<f32, N>::splat(0.5))
                                    })))))
                                * (Simd::<f32, N>::splat(cache.df_overworld__factor)));
                            let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                            __mask.select(__v, __v * Simd::<f32, N>::splat(0.25))
                        }) * (Simd::<f32, N>::splat(4.0)))) + (blended_noise_value_v));
                        let __cse_68 = compute_overworld__caves__entrances_simd::<
                            N,
                        >(noises, cache, x, ys, z);
                        let __in_mask = __branch_input_67
                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                            & __branch_input_67.simd_lt(Simd::<f32, N>::splat(1.5625));
                        if __in_mask.all() {
                            (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))))
                        } else if !__in_mask.any() {
                            ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                })
                        } else {
                            let __ir = (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))));
                            let __or = ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                });
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else {
                    let __lerp_first = Simd::<f32, N>::splat(-0.078125);
                    let __lerp_second = {
                        let __branch_input_67 = (((({
                            let __v = ((((compute_overworld__depth_simd::<
                                N,
                            >(noises, cache, x, ys, z))
                                + (((Simd::<f32, N>::splat(cache.df_overworld__jaggedness))
                                    * ({
                                        let __v = Simd::<f32, N>::splat(cache.inline_noise_1);
                                        let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                                        __mask.select(__v, __v * Simd::<f32, N>::splat(0.5))
                                    })))))
                                * (Simd::<f32, N>::splat(cache.df_overworld__factor)));
                            let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                            __mask.select(__v, __v * Simd::<f32, N>::splat(0.25))
                        }) * (Simd::<f32, N>::splat(4.0)))) + (blended_noise_value_v));
                        let __cse_68 = compute_overworld__caves__entrances_simd::<
                            N,
                        >(noises, cache, x, ys, z);
                        let __in_mask = __branch_input_67
                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                            & __branch_input_67.simd_lt(Simd::<f32, N>::splat(1.5625));
                        if __in_mask.all() {
                            (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))))
                        } else if !__in_mask.any() {
                            ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                })
                        } else {
                            let __ir = (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))));
                            let __or = ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                });
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __lerp_value = __lerp_first
                        + __lerp_alpha * (__lerp_second - __lerp_first);
                    __zero
                        .select(__lerp_first, __one.select(__lerp_second, __lerp_value))
                }
            }
        } else {
            let __lerp_first = Simd::<f32, N>::splat(0.1171875);
            let __lerp_second = {
                let __lerp_alpha = {
                    let __coordinate = ys
                        .cast::<i32>()
                        .simd_max(Simd::splat(240))
                        .simd_min(Simd::splat(256)) - Simd::splat(240);
                    Simd::<f32, N>::splat(1.0)
                        + __coordinate.cast::<f32>()
                            * Simd::<f32, N>::splat((0.0 - 1.0) / (256 - 240) as f32)
                };
                let __zero = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(0.0));
                let __one = __lerp_alpha.simd_eq(Simd::<f32, N>::splat(1.0));
                if __zero.all() {
                    Simd::<f32, N>::splat(-0.078125)
                } else if __one.all() {
                    {
                        let __branch_input_67 = (((({
                            let __v = ((((compute_overworld__depth_simd::<
                                N,
                            >(noises, cache, x, ys, z))
                                + (((Simd::<f32, N>::splat(cache.df_overworld__jaggedness))
                                    * ({
                                        let __v = Simd::<f32, N>::splat(cache.inline_noise_1);
                                        let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                                        __mask.select(__v, __v * Simd::<f32, N>::splat(0.5))
                                    })))))
                                * (Simd::<f32, N>::splat(cache.df_overworld__factor)));
                            let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                            __mask.select(__v, __v * Simd::<f32, N>::splat(0.25))
                        }) * (Simd::<f32, N>::splat(4.0)))) + (blended_noise_value_v));
                        let __cse_68 = compute_overworld__caves__entrances_simd::<
                            N,
                        >(noises, cache, x, ys, z);
                        let __in_mask = __branch_input_67
                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                            & __branch_input_67.simd_lt(Simd::<f32, N>::splat(1.5625));
                        if __in_mask.all() {
                            (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))))
                        } else if !__in_mask.any() {
                            ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                })
                        } else {
                            let __ir = (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))));
                            let __or = ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                });
                            __in_mask.select(__ir, __or)
                        }
                    }
                } else {
                    let __lerp_first = Simd::<f32, N>::splat(-0.078125);
                    let __lerp_second = {
                        let __branch_input_67 = (((({
                            let __v = ((((compute_overworld__depth_simd::<
                                N,
                            >(noises, cache, x, ys, z))
                                + (((Simd::<f32, N>::splat(cache.df_overworld__jaggedness))
                                    * ({
                                        let __v = Simd::<f32, N>::splat(cache.inline_noise_1);
                                        let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                                        __mask.select(__v, __v * Simd::<f32, N>::splat(0.5))
                                    })))))
                                * (Simd::<f32, N>::splat(cache.df_overworld__factor)));
                            let __mask = __v.simd_gt(Simd::<f32, N>::splat(0.0));
                            __mask.select(__v, __v * Simd::<f32, N>::splat(0.25))
                        }) * (Simd::<f32, N>::splat(4.0)))) + (blended_noise_value_v));
                        let __cse_68 = compute_overworld__caves__entrances_simd::<
                            N,
                        >(noises, cache, x, ys, z);
                        let __in_mask = __branch_input_67
                            .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                            & __branch_input_67.simd_lt(Simd::<f32, N>::splat(1.5625));
                        if __in_mask.all() {
                            (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))))
                        } else if !__in_mask.any() {
                            ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                })
                        } else {
                            let __ir = (__branch_input_67)
                                .simd_min(((__cse_68) * (Simd::<f32, N>::splat(5.0))));
                            let __or = ((((((({
                                let __v = noises
                                    .n_cave_layer
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(8.0),
                                        z * 1.0,
                                    );
                                __v * __v
                            }) * (Simd::<f32, N>::splat(4.0))))
                                + ((((((noises
                                    .n_cave_cheese
                                    .get_value_y_simd(
                                        x * 1.0,
                                        ys * Simd::<f64, N>::splat(0.6666666666666666),
                                        z * 1.0,
                                    )) + (Simd::<f32, N>::splat(0.27))))
                                    .simd_max(Simd::<f32, N>::splat(-1.0))
                                    .simd_min(Simd::<f32, N>::splat(1.0)))
                                    + ((((((__branch_input_67)
                                        * (Simd::<f32, N>::splat(-0.64))))
                                        + (Simd::<f32, N>::splat(1.5))))
                                        .simd_max(Simd::<f32, N>::splat(0.0))
                                        .simd_min(Simd::<f32, N>::splat(0.5)))))))
                                .simd_min(__cse_68))
                                .simd_min(
                                    ((compute_overworld__caves__spaghetti_2d_simd::<
                                        N,
                                    >(noises, cache, x, ys, z))
                                        + (compute_overworld__caves__spaghetti_roughness_function_simd::<
                                            N,
                                        >(noises, cache, x, ys, z))),
                                ))
                                .simd_max({
                                    let __branch_input_69 = compute_overworld__caves__pillars_simd::<
                                        N,
                                    >(noises, cache, x, ys, z);
                                    let __in_mask = __branch_input_69
                                        .simd_ge(Simd::<f32, N>::splat(-1000000.0))
                                        & __branch_input_69.simd_lt(Simd::<f32, N>::splat(0.03));
                                    if __in_mask.all() {
                                        Simd::<f32, N>::splat(-1000000.0)
                                    } else if !__in_mask.any() {
                                        __branch_input_69
                                    } else {
                                        let __ir = Simd::<f32, N>::splat(-1000000.0);
                                        let __or = __branch_input_69;
                                        __in_mask.select(__ir, __or)
                                    }
                                });
                            __in_mask.select(__ir, __or)
                        }
                    };
                    let __lerp_value = __lerp_first
                        + __lerp_alpha * (__lerp_second - __lerp_first);
                    __zero
                        .select(__lerp_first, __one.select(__lerp_second, __lerp_value))
                }
            };
            let __lerp_value = __lerp_first
                + __lerp_alpha * (__lerp_second - __lerp_first);
            __zero.select(__lerp_first, __one.select(__lerp_second, __lerp_value))
        }
    }) * (Simd::<f32, N>::splat(0.64))))
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 0] = __values_simd_0[lane];
    }
    let __values_simd_1 = ({
        let __branch_input_70 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_70.simd_ge(Simd::<f32, N>::splat(-60.0))
            & __branch_input_70.simd_lt(Simd::<f32, N>::splat(321.0));
        if __in_mask.all() {
            noises
                .n_noodle
                .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(-1.0)
        } else {
            let __ir = noises
                .n_noodle
                .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0);
            let __or = Simd::<f32, N>::splat(-1.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 1] = __values_simd_1[lane];
    }
    let __values_simd_2 = ({
        let __branch_input_71 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_71.simd_ge(Simd::<f32, N>::splat(-60.0))
            & __branch_input_71.simd_lt(Simd::<f32, N>::splat(321.0));
        if __in_mask.all() {
            ((((noises
                .n_noodle_thickness
                .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
                * (Simd::<f32, N>::splat(-0.025)))) + (Simd::<f32, N>::splat(-0.075)))
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = ((((noises
                .n_noodle_thickness
                .get_value_y_simd(x * 1.0, ys * Simd::<f64, N>::splat(1.0), z * 1.0))
                * (Simd::<f32, N>::splat(-0.025)))) + (Simd::<f32, N>::splat(-0.075)));
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 2] = __values_simd_2[lane];
    }
    let __values_simd_3 = ({
        let __branch_input_72 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_72.simd_ge(Simd::<f32, N>::splat(-60.0))
            & __branch_input_72.simd_lt(Simd::<f32, N>::splat(321.0));
        if __in_mask.all() {
            noises
                .n_noodle_ridge_a
                .get_value_y_simd(
                    x * 2.6666666666666665,
                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                    z * 2.6666666666666665,
                )
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_noodle_ridge_a
                .get_value_y_simd(
                    x * 2.6666666666666665,
                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                    z * 2.6666666666666665,
                );
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 3] = __values_simd_3[lane];
    }
    let __values_simd_4 = ({
        let __branch_input_73 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_73.simd_ge(Simd::<f32, N>::splat(-60.0))
            & __branch_input_73.simd_lt(Simd::<f32, N>::splat(321.0));
        if __in_mask.all() {
            noises
                .n_noodle_ridge_b
                .get_value_y_simd(
                    x * 2.6666666666666665,
                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                    z * 2.6666666666666665,
                )
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_noodle_ridge_b
                .get_value_y_simd(
                    x * 2.6666666666666665,
                    ys * Simd::<f64, N>::splat(2.6666666666666665),
                    z * 2.6666666666666665,
                );
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 4] = __values_simd_4[lane];
    }
    let __values_simd_5 = ({
        let __branch_input_74 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_74.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_74.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 5] = __values_simd_5[lane];
    }
    let __values_simd_6 = ({
        let __branch_input_75 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_75.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_75.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_vein_a
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(1.0)
        } else {
            let __ir = noises
                .n_ore_vein_a
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0);
            let __or = Simd::<f32, N>::splat(1.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 6] = __values_simd_6[lane];
    }
    let __values_simd_7 = ({
        let __branch_input_76 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_76.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_76.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_vein_b
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(1.0)
        } else {
            let __ir = noises
                .n_ore_vein_b
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0);
            let __or = Simd::<f32, N>::splat(1.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 7] = __values_simd_7[lane];
    }
    let __values_simd_8 = ({
        let __branch_input_77 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_77.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_77.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 8] = __values_simd_8[lane];
    }
    let __values_simd_9 = ({
        let __branch_input_78 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_78.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_78.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 9] = __values_simd_9[lane];
    }
    let __values_simd_10 = ({
        let __branch_input_79 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_79.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_79.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 10] = __values_simd_10[lane];
    }
    let __values_simd_11 = ({
        let __branch_input_80 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_80.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_80.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_vein_a
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(1.0)
        } else {
            let __ir = noises
                .n_ore_vein_a
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0);
            let __or = Simd::<f32, N>::splat(1.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 11] = __values_simd_11[lane];
    }
    let __values_simd_12 = ({
        let __branch_input_81 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_81.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_81.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_vein_b
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(1.0)
        } else {
            let __ir = noises
                .n_ore_vein_b
                .get_value_y_simd(x * 4.0, ys * Simd::<f64, N>::splat(4.0), z * 4.0);
            let __or = Simd::<f32, N>::splat(1.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 12] = __values_simd_12[lane];
    }
    let __values_simd_13 = ({
        let __branch_input_82 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_82.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_82.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 13] = __values_simd_13[lane];
    }
    let __values_simd_14 = ({
        let __branch_input_83 = compute_y_simd::<N>(noises, cache, x, ys, z);
        let __in_mask = __branch_input_83.simd_ge(Simd::<f32, N>::splat(-64.0))
            & __branch_input_83.simd_lt(Simd::<f32, N>::splat(57.0));
        if __in_mask.all() {
            noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5)
        } else if !__in_mask.any() {
            Simd::<f32, N>::splat(0.0)
        } else {
            let __ir = noises
                .n_ore_veininess
                .get_value_y_simd(x * 1.5, ys * Simd::<f64, N>::splat(1.5), z * 1.5);
            let __or = Simd::<f32, N>::splat(0.0);
            __in_mask.select(__ir, __or)
        }
    })
        .to_array();
    for lane in 0..N {
        out[lane * INTERPOLATED_COUNT + 14] = __values_simd_14[lane];
    }
}
/// Combine interpolated values for `final_density`.
#[expect(
    unused_variables,
    reason = "generated function has a fixed signature; not all parameters are used in every dimension"
)]
pub fn combine_interpolated(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    interpolated: &[f32],
    _x: i32,
    y: i32,
    _z: i32,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    let y = y as f64;
    ((((({
        let __sc_a = ({
            let c = ((interpolated[0]) as f32).clamp(-1.0, 1.0);
            c / 2.0 - c * c * c / 24.0
        }) as f32;
        let __sc_b = (({
            let __branch_input_84 = (interpolated[1]) as f32;
            if __branch_input_84 >= -1000000.0 && __branch_input_84 < 0.0 {
                (64.0) as f32
            } else {
                ((((interpolated[2]) as f32)
                    + ((((({
                        let __sc_a = (((interpolated[3]) as f32).abs()) as f32;
                        let __sc_b = (((interpolated[4]) as f32).abs()) as f32;
                        if __sc_a > __sc_b { __sc_a } else { __sc_b }
                    }) as f32) * ((1.5) as f32))) as f32))) as f32
            }
        }) as f32) as f32;
        if __sc_a < __sc_b { __sc_a } else { __sc_b }
    }) as f32) + ((0.0) as f32))) as f32) as f32
}
/// Combine interpolated values for `vein_toggle`.
#[expect(
    unused_variables,
    reason = "generated function has a fixed signature; not all parameters are used in every dimension"
)]
pub fn combine_vein_toggle(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    interpolated: &[f32],
    _x: i32,
    y: i32,
    _z: i32,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    let y = y as f64;
    0.0
}
/// Combine interpolated values for `vein_ridged`.
#[expect(
    unused_variables,
    reason = "generated function has a fixed signature; not all parameters are used in every dimension"
)]
pub fn combine_vein_ridged(
    noises: &OverworldNoises,
    cache: &OverworldColumnCache,
    interpolated: &[f32],
    _x: i32,
    y: i32,
    _z: i32,
) -> f32 {
    let x = cache.x as f64;
    let z = cache.z as f64;
    let y = y as f64;
    0.0
}
#[expect(unused_variables, reason = "generated function has a fixed signature")]
#[inline]
pub fn combine_material_ore_vein_0_density(
    noises: &OverworldNoises,
    cache: &mut OverworldColumnCache,
    interpolated: &[f32],
    x: i32,
    y: i32,
    z: i32,
) -> f32 {
    let x = x as f64;
    let z = z as f64;
    let y = y as f64;
    (({
        let __branch_input_85 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_85 >= 0.0 && __branch_input_85 < 50.0 {
            ({
                let __branch_input_87 = ((({
                    let __branch_input_86 = (((interpolated[5]) as f32) as f32) as f32;
                    if __branch_input_86 >= -0.4 && __branch_input_86 < 0.4 {
                        (-1.0) as f32
                    } else {
                        ((((0.08) as f32)
                            - (({
                                let __sc_a = (((interpolated[6]) as f32).abs()) as f32;
                                let __sc_b = (((interpolated[7]) as f32).abs()) as f32;
                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                            }) as f32))) as f32
                    }
                }) as f32) as f32) as f32;
                if __branch_input_87 >= 0.0 {
                    ({
                        let __branch_input_88 = (((((((((interpolated[8]) as f32) as f32)
                            as f32) - ((0.4) as f32))) as f32)
                            + (((((((((({
                                let __sc_a = ((((50.0) as f32) - (__branch_input_85)))
                                    as f32;
                                if __sc_a <= -4064.0 {
                                    __sc_a
                                } else {
                                    let __sc_b = (((__branch_input_85) - ((0.0) as f32)))
                                        as f32;
                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                }
                            }) as f32)
                                .clamp(0.0, 20.0)) as f32) * ((0.01) as f32))) as f32)
                                + ((-0.2) as f32))) as f32))) as f32;
                        if __branch_input_88 >= 0.0 && __branch_input_88 < 1000000.0 {
                            (0.7) as f32
                        } else {
                            (-1.0) as f32
                        }
                    }) as f32
                } else {
                    (-1.0) as f32
                }
            }) as f32
        } else {
            (-1.0) as f32
        }
    }) as f32) as f32
}
#[expect(unused_variables, reason = "generated function has a fixed signature")]
#[inline]
pub fn combine_material_ore_vein_0_richness(
    noises: &OverworldNoises,
    cache: &mut OverworldColumnCache,
    interpolated: &[f32],
    x: i32,
    y: i32,
    z: i32,
) -> f32 {
    let x = x as f64;
    let z = z as f64;
    let y = y as f64;
    ((((((((((((((interpolated[9]) as f32) as f32) as f32).abs()) as f32)
        .clamp(0.4, 0.6)) as f32) * ((1.0) as f32))) as f32) + ((-0.3) as f32))) as f32)
        as f32
}
#[expect(unused_variables, reason = "generated function has a fixed signature")]
#[inline]
pub fn combine_material_ore_vein_1_density(
    noises: &OverworldNoises,
    cache: &mut OverworldColumnCache,
    interpolated: &[f32],
    x: i32,
    y: i32,
    z: i32,
) -> f32 {
    let x = x as f64;
    let z = z as f64;
    let y = y as f64;
    (({
        let __branch_input_89 = (compute_y(noises, cache, x, y, z)) as f32;
        if __branch_input_89 >= -60.0 && __branch_input_89 < -8.0 {
            ({
                let __branch_input_91 = ((({
                    let __branch_input_90 = (((interpolated[10]) as f32) as f32) as f32;
                    if __branch_input_90 >= -0.4 && __branch_input_90 < 0.4 {
                        (-1.0) as f32
                    } else {
                        ((((0.08) as f32)
                            - (({
                                let __sc_a = (((interpolated[11]) as f32).abs()) as f32;
                                let __sc_b = (((interpolated[12]) as f32).abs()) as f32;
                                if __sc_a > __sc_b { __sc_a } else { __sc_b }
                            }) as f32))) as f32
                    }
                }) as f32) as f32) as f32;
                if __branch_input_91 >= 0.0 {
                    ({
                        let __branch_input_92 = ((((((((-((((interpolated[13]) as f32)
                            as f32) as f32))) as f32) - ((0.4) as f32))) as f32)
                            + (((((((((({
                                let __sc_a = ((((-8.0) as f32) - (__branch_input_89)))
                                    as f32;
                                if __sc_a <= -4004.0 {
                                    __sc_a
                                } else {
                                    let __sc_b = (((__branch_input_89) - ((-60.0) as f32)))
                                        as f32;
                                    if __sc_a < __sc_b { __sc_a } else { __sc_b }
                                }
                            }) as f32)
                                .clamp(0.0, 20.0)) as f32) * ((0.01) as f32))) as f32)
                                + ((-0.2) as f32))) as f32))) as f32;
                        if __branch_input_92 >= 0.0 && __branch_input_92 < 1000000.0 {
                            (0.7) as f32
                        } else {
                            (-1.0) as f32
                        }
                    }) as f32
                } else {
                    (-1.0) as f32
                }
            }) as f32
        } else {
            (-1.0) as f32
        }
    }) as f32) as f32
}
#[expect(unused_variables, reason = "generated function has a fixed signature")]
#[inline]
pub fn combine_material_ore_vein_1_richness(
    noises: &OverworldNoises,
    cache: &mut OverworldColumnCache,
    interpolated: &[f32],
    x: i32,
    y: i32,
    z: i32,
) -> f32 {
    let x = x as f64;
    let z = z as f64;
    let y = y as f64;
    ((((((((((((((interpolated[14]) as f32) as f32) as f32).abs()) as f32)
        .clamp(0.4, 0.6)) as f32) * ((1.0) as f32))) as f32) + ((-0.3) as f32))) as f32)
        as f32
}
/// Noise settings for this dimension, parsed from the datapack.
pub struct OverworldNoiseSettings;
impl OverworldNoiseSettings {
    /// Minimum Y coordinate for this dimension.
    pub const MIN_Y: i32 = -64i32;
    /// Total height of the world in blocks.
    pub const HEIGHT: i32 = 384i32;
    /// Sea level Y coordinate.
    pub const SEA_LEVEL: i32 = 63i32;
    /// Cell width in blocks (XZ).
    pub const CELL_WIDTH: i32 = 4i32;
    /// Cell height in blocks (Y).
    pub const CELL_HEIGHT: i32 = 8i32;
    /// Whether aquifers are enabled.
    pub const AQUIFERS_ENABLED: bool = true;
    /// Whether ore veins are enabled.
    pub const ORE_VEINS_ENABLED: bool = false;
    /// Whether the material rule contains ore veins.
    pub const MATERIAL_ORE_VEINS_ENABLED: bool = true;
    /// Whether this dimension uses Java's LCG random (true) or Xoroshiro (false).
    pub const LEGACY_RANDOM_SOURCE: bool = false;
    /// Get the default block state ID for this dimension.
    #[inline]
    pub fn default_block_id() -> steel_utils::BlockStateId {
        steel_registry::REGISTRY
            .blocks
            .get_default_state_id(&steel_registry::vanilla_blocks::STONE)
    }
    /// Get the default fluid state ID for this dimension.
    #[inline]
    pub fn default_fluid_id() -> steel_utils::BlockStateId {
        steel_registry::REGISTRY
            .blocks
            .get_default_state_id(&steel_registry::vanilla_blocks::WATER)
    }
}
impl steel_worldgen::density::NoiseSettings for OverworldNoiseSettings {
    const MIN_Y: i32 = -64i32;
    const HEIGHT: i32 = 384i32;
    const SEA_LEVEL: i32 = 63i32;
    const CELL_WIDTH: i32 = 4i32;
    const CELL_HEIGHT: i32 = 8i32;
    const AQUIFERS_ENABLED: bool = true;
    const ORE_VEINS_ENABLED: bool = false;
    const MATERIAL_ORE_VEINS_ENABLED: bool = true;
    const LEGACY_RANDOM_SOURCE: bool = false;
    #[inline]
    fn default_block_id() -> steel_utils::BlockStateId {
        OverworldNoiseSettings::default_block_id()
    }
    #[inline]
    fn default_fluid_id() -> steel_utils::BlockStateId {
        OverworldNoiseSettings::default_fluid_id()
    }
}
impl Default for OverworldColumnCache {
    fn default() -> Self {
        Self::new()
    }
}
impl steel_worldgen::density::ColumnCache for OverworldColumnCache {
    type Noises = OverworldNoises;
    #[inline]
    fn ensure(&mut self, x: i32, z: i32, noises: &Self::Noises) {
        OverworldColumnCache::ensure(self, x, z, noises)
    }
    #[inline]
    fn init_grid(
        &mut self,
        chunk_block_x: i32,
        chunk_block_z: i32,
        noises: &Self::Noises,
    ) {
        OverworldColumnCache::init_grid(self, chunk_block_x, chunk_block_z, noises)
    }
}
impl steel_worldgen::density::DimensionNoises for OverworldNoises {
    type ColumnCache = OverworldColumnCache;
    type Settings = OverworldNoiseSettings;
    fn create(
        seed: u64,
        splitter: &steel_utils::random::RandomSplitter,
        params: &rustc_hash::FxHashMap<String, steel_worldgen::density::NoiseParameters>,
    ) -> Self {
        OverworldNoises::create(seed, splitter, params)
    }
    #[inline]
    fn router_final_density(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_final_density(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_depth(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_depth(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn aquifer_needs_column_cache() -> bool {
        AQUIFER_NEEDS_COLUMN_CACHE
    }
    #[inline]
    fn router_barrier(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_barrier(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_fluid_level_floodedness(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_fluid_level_floodedness(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_fluid_level_spread(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_fluid_level_spread(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_lava(&self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32) -> f32 {
        router_lava(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_vein_toggle(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        0.0
    }
    #[inline]
    fn router_vein_ridged(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        0.0
    }
    #[inline]
    fn router_vein_gap(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        0.0
    }
    #[inline]
    fn router_preliminary_surface_level(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_preliminary_surface_level(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_erosion(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_erosion(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_continentalness(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_continentalness(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_temperature(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_temperature(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_vegetation(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_vegetation(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn router_ridges(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        router_ridges(self, cache, x as f64, y as f64, z as f64)
    }
    #[inline]
    fn interpolated_count() -> usize {
        INTERPOLATED_COUNT
    }
    fn vein_interp_enabled() -> bool {
        VEIN_INTERP_ENABLED
    }
    #[inline]
    fn final_density_nonpositive_channels() -> Option<&'static [usize]> {
        FINAL_DENSITY_NONPOSITIVE_CHANNELS
    }
    #[inline]
    fn compute_noise_column(&self, x: i32, block_ys: &[i32], z: i32, out: &mut [f32]) {
        self.blended_noise.compute_column(x, block_ys, z, out);
    }
    #[inline]
    fn fill_cell_corner_densities(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        y: i32,
        z: i32,
        blended_noise_value: f32,
        out: &mut [f32],
    ) {
        fill_cell_corner_densities(self, cache, x, y, z, blended_noise_value, out)
    }
    #[inline]
    fn fill_cell_corner_densities_y_simd<const N: usize>(
        &self,
        cache: &mut Self::ColumnCache,
        x: i32,
        ys: [i32; N],
        z: i32,
        blended_noise_values: [f32; N],
        out: &mut [f32],
    ) {
        fill_cell_corner_densities_y_simd::<
            N,
        >(self, cache, x, ys, z, blended_noise_values, out)
    }
    #[inline]
    fn combine_interpolated(
        &self,
        cache: &mut Self::ColumnCache,
        interpolated: &[f32],
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        combine_interpolated(self, cache, interpolated, x, y, z)
    }
    #[inline]
    fn combine_vein_toggle(
        &self,
        cache: &mut Self::ColumnCache,
        interpolated: &[f32],
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        combine_vein_toggle(self, cache, interpolated, x, y, z)
    }
    #[inline]
    fn combine_vein_ridged(
        &self,
        cache: &mut Self::ColumnCache,
        interpolated: &[f32],
        x: i32,
        y: i32,
        z: i32,
    ) -> f32 {
        combine_vein_ridged(self, cache, interpolated, x, y, z)
    }
    fn surface_noise_ids() -> &'static [&'static str] {
        &[
            "minecraft:surface",
            "minecraft:surface_swamp",
            "minecraft:packed_ice",
            "minecraft:ice",
            "minecraft:powder_snow",
            "minecraft:calcite",
            "minecraft:gravel",
            "minecraft:sulfur_cave_gradient",
            "minecraft:small_patch",
        ]
    }
    fn surface_gradient_ids() -> &'static [&'static str] {
        &["minecraft:bedrock_floor", "minecraft:deepslate"]
    }
    fn surface_rule_block_states() -> &'static [steel_utils::BlockStateId] {
        {
            static BLOCK_STATES: std::sync::OnceLock<Box<[steel_utils::BlockStateId]>> = std::sync::OnceLock::new();
            BLOCK_STATES
                .get_or_init(|| {
                    Box::from([
                        steel_registry::vanilla_blocks::BEDROCK.default_state(),
                        steel_registry::vanilla_blocks::COARSE_DIRT.default_state(),
                        steel_registry::vanilla_blocks::GRASS_BLOCK.default_state(),
                        steel_registry::vanilla_blocks::DIRT.default_state(),
                        steel_registry::vanilla_blocks::WATER.default_state(),
                        steel_registry::vanilla_blocks::ORANGE_TERRACOTTA
                            .default_state(),
                        steel_registry::vanilla_blocks::TERRACOTTA.default_state(),
                        steel_registry::vanilla_blocks::RED_SANDSTONE.default_state(),
                        steel_registry::vanilla_blocks::RED_SAND.default_state(),
                        steel_registry::vanilla_blocks::WHITE_TERRACOTTA.default_state(),
                        steel_registry::vanilla_blocks::STONE.default_state(),
                        steel_registry::vanilla_blocks::GRAVEL.default_state(),
                        steel_registry::vanilla_blocks::AIR.default_state(),
                        steel_registry::vanilla_blocks::PACKED_ICE.default_state(),
                        steel_registry::vanilla_blocks::ICE.default_state(),
                        steel_registry::vanilla_blocks::SNOW_BLOCK.default_state(),
                        steel_registry::vanilla_blocks::POWDER_SNOW.default_state(),
                        steel_registry::vanilla_blocks::CALCITE.default_state(),
                        steel_registry::vanilla_blocks::SANDSTONE.default_state(),
                        steel_registry::vanilla_blocks::SAND.default_state(),
                        steel_registry::vanilla_blocks::CINNABAR.default_state(),
                        steel_registry::vanilla_blocks::SULFUR.default_state(),
                        steel_registry::vanilla_blocks::MUD.default_state(),
                        steel_registry::vanilla_blocks::PODZOL.default_state(),
                        steel_registry::vanilla_blocks::MYCELIUM.default_state(),
                        steel_registry::vanilla_blocks::DEEPSLATE.default_state(),
                    ])
                })
        }
    }
    fn surface_rule_uses_biome() -> bool {
        true
    }
    fn surface_rule_biome_sets() -> &'static [Box<[u16]>] {
        {
            static BIOME_SETS: std::sync::OnceLock<Box<[Box<[u16]>]>> = std::sync::OnceLock::new();
            BIOME_SETS
                .get_or_init(|| Box::from([
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WOODED_BADLANDS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::SWAMP,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::MANGROVE_SWAMP,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::BADLANDS,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::ERODED_BADLANDS,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WOODED_BADLANDS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::FROZEN_OCEAN,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::DEEP_FROZEN_OCEAN,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::FROZEN_PEAKS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::SNOWY_SLOPES,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::JAGGED_PEAKS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::GROVE,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::STONY_PEAKS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::STONY_SHORE,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WINDSWEPT_HILLS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WARM_OCEAN,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::BEACH,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::SNOWY_BEACH,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::DESERT,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::DRIPSTONE_CAVES,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::SULFUR_CAVES,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WINDSWEPT_SAVANNA,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WINDSWEPT_GRAVELLY_HILLS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::OLD_GROWTH_PINE_TAIGA,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::OLD_GROWTH_SPRUCE_TAIGA,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::ICE_SPIKES,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::MUSHROOM_FIELDS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::DAPPLED_FOREST,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::FROZEN_PEAKS,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::JAGGED_PEAKS,
                        ) as u16,
                    ]),
                    Box::from([
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::WARM_OCEAN,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::LUKEWARM_OCEAN,
                        ) as u16,
                        steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::DEEP_LUKEWARM_OCEAN,
                        ) as u16,
                    ]),
                ]))
        }
    }
    fn surface_rule_below_preliminary_surface() -> &'static steel_worldgen::surface_partial::PartialSurfaceRule {
        static RULE: steel_worldgen::surface_partial::PartialSurfaceRule = steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
            &[
                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                    steel_worldgen::surface_partial::PartialSurfaceCondition::VerticalGradient {
                        true_at_and_below: -64i32,
                        false_at_and_above: -59i32,
                    },
                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(0usize),
                ),
                steel_worldgen::surface_partial::PartialSurfaceRule::Opaque,
                steel_worldgen::surface_partial::PartialSurfaceRule::Opaque,
                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                    steel_worldgen::surface_partial::PartialSurfaceCondition::AbovePreliminarySurface,
                    &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                        &[
                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                    &[
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                0usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                    &[
                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                1usize,
                                                            ),
                                                        ),
                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                1usize,
                                                            ),
                                                        ),
                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                1usize,
                                                            ),
                                                        ),
                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        2usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    3usize,
                                                                ),
                                                            ],
                                                        ),
                                                    ],
                                                ),
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                1usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                    62i32,
                                                ),
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Not(
                                                        &steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                            63i32,
                                                        ),
                                                    ),
                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            4usize,
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                2usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                    60i32,
                                                ),
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Not(
                                                        &steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                            63i32,
                                                        ),
                                                    ),
                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            4usize,
                                                        ),
                                                    ),
                                                ),
                                            ),
                                        ),
                                    ],
                                ),
                            ),
                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                    3usize,
                                ),
                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                    &[
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                &[
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                            256i32,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            5usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        6usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        6usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        6usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Opaque,
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        7usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    8usize,
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Not(
                                                            &steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            5usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            9usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                        &[
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    10usize,
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                11usize,
                                                            ),
                                                        ],
                                                    ),
                                                ],
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                &[
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::YAtLeast(
                                                            63i32,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Not(
                                                                &steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            ),
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                5usize,
                                                            ),
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Opaque,
                                                ],
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                    9usize,
                                                ),
                                            ),
                                        ),
                                    ],
                                ),
                            ),
                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                        &[
                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                    4usize,
                                                ),
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                        12usize,
                                                    ),
                                                ),
                                            ),
                                            steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                &[
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            5usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        13usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        13usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        14usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            6usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            16usize,
                                                                        ),
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            7usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            8usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            16usize,
                                                                        ),
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                        &[
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    9usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                17usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    10usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                                &[
                                                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                            10usize,
                                                                                        ),
                                                                                    ),
                                                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        11usize,
                                                                                    ),
                                                                                ],
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    11usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    12usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                18usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            19usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    13usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                18usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            19usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    14usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    10usize,
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    15usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                            &[
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        20usize,
                                                                                    ),
                                                                                ),
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        21usize,
                                                                                    ),
                                                                                ),
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        20usize,
                                                                                    ),
                                                                                ),
                                                                            ],
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    2usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    22usize,
                                                                ),
                                                            ),
                                                        ],
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            16usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        1usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            17usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                        &[
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                    10usize,
                                                                                ),
                                                                            ),
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                11usize,
                                                                            ),
                                                                        ],
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                        &[
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                    2usize,
                                                                                ),
                                                                            ),
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                3usize,
                                                                            ),
                                                                        ],
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                10usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            11usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            18usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        1usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        23usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            19usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                15usize,
                                                            ),
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            20usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            24usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            21usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                1usize,
                                                            ),
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                        &[
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    2usize,
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                3usize,
                                                            ),
                                                        ],
                                                    ),
                                                ],
                                            ),
                                        ],
                                    ),
                                ),
                            ),
                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                    &[
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                    4usize,
                                                ),
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                        4usize,
                                                    ),
                                                ),
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                &[
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            5usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        13usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        13usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        14usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            6usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            16usize,
                                                                        ),
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        15usize,
                                                                    ),
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            7usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            10usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            8usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            16usize,
                                                                        ),
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    3usize,
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                        &[
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    9usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                17usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    10usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                                &[
                                                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                            10usize,
                                                                                        ),
                                                                                    ),
                                                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        11usize,
                                                                                    ),
                                                                                ],
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    11usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    12usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                18usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            19usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    13usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                18usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            19usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    14usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    10usize,
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    15usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                            &[
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        20usize,
                                                                                    ),
                                                                                ),
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        21usize,
                                                                                    ),
                                                                                ),
                                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                        20usize,
                                                                                    ),
                                                                                ),
                                                                            ],
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            10usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ),
                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                                    2usize,
                                                                ),
                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                    22usize,
                                                                ),
                                                            ),
                                                        ],
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            16usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                10usize,
                                                            ),
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                            17usize,
                                                        ),
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                            &[
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                        &[
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                    10usize,
                                                                                ),
                                                                            ),
                                                                            steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                11usize,
                                                                            ),
                                                                        ],
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        10usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                        3usize,
                                                                    ),
                                                                ),
                                                                steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                                    &[
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                                            steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                                10usize,
                                                                            ),
                                                                        ),
                                                                        steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                                            11usize,
                                                                        ),
                                                                    ],
                                                                ),
                                                            ],
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                        3usize,
                                                    ),
                                                ],
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                12usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                    18usize,
                                                ),
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                13usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                    18usize,
                                                ),
                                            ),
                                        ),
                                    ],
                                ),
                            ),
                            steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                    &[
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                22usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                10usize,
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                                23usize,
                                            ),
                                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                                &[
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                            18usize,
                                                        ),
                                                    ),
                                                    steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                        19usize,
                                                    ),
                                                ],
                                            ),
                                        ),
                                        steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                            &[
                                                steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                                    steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                                    &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                        10usize,
                                                    ),
                                                ),
                                                steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                                    11usize,
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                        ],
                    ),
                ),
                steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                    &[
                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                            steel_worldgen::surface_partial::PartialSurfaceCondition::BiomeSet(
                                15usize,
                            ),
                            &steel_worldgen::surface_partial::PartialSurfaceRule::Sequence(
                                &[
                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                            20usize,
                                        ),
                                    ),
                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                            21usize,
                                        ),
                                    ),
                                    steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                                        steel_worldgen::surface_partial::PartialSurfaceCondition::Opaque,
                                        &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                            20usize,
                                        ),
                                    ),
                                ],
                            ),
                        ),
                        steel_worldgen::surface_partial::PartialSurfaceRule::Condition(
                            steel_worldgen::surface_partial::PartialSurfaceCondition::VerticalGradient {
                                true_at_and_below: 0i32,
                                false_at_and_above: 8i32,
                            },
                            &steel_worldgen::surface_partial::PartialSurfaceRule::Block(
                                25usize,
                            ),
                        ),
                    ],
                ),
            ],
        );
        &RULE
    }
    fn surface_rule_uses_preliminary_surface() -> bool {
        true
    }
    fn surface_rule_uses_surface_secondary() -> bool {
        true
    }
    fn surface_rule_uses_steep() -> bool {
        true
    }
    fn try_apply_surface_rule(
        ctx: &mut steel_worldgen::surface::SurfaceRuleContext<'_>,
    ) -> Option<steel_utils::BlockStateId> {
        Self::apply_surface_rule_impl(ctx)
    }
    fn material_ore_vein_value_count() -> usize {
        4usize
    }
    fn material_ore_vein_value_height() -> usize {
        114usize
    }
    fn fill_material_ore_vein_values(
        &self,
        cache: &mut Self::ColumnCache,
        interpolated: &[f32],
        x: i32,
        y: i32,
        z: i32,
        out: &mut [f32],
    ) {
        out[0usize] = combine_material_ore_vein_0_density(
            self,
            cache,
            interpolated,
            x,
            y,
            z,
        ) as f32;
        out[0usize + 1] = combine_material_ore_vein_0_richness(
            self,
            cache,
            interpolated,
            x,
            y,
            z,
        ) as f32;
        out[2usize] = combine_material_ore_vein_1_density(
            self,
            cache,
            interpolated,
            x,
            y,
            z,
        ) as f32;
        out[2usize + 1] = combine_material_ore_vein_1_richness(
            self,
            cache,
            interpolated,
            x,
            y,
            z,
        ) as f32;
    }
    fn fill_prefilled_material_ore_vein_results(
        &self,
        cache: &mut Self::ColumnCache,
        ore_veinifier: &steel_worldgen::noise::OreVeinifier,
        values: &[f32],
        x: i32,
        y: i32,
        z: i32,
        out: &mut [Option<steel_utils::BlockStateId>],
    ) {
        let ore_vein_states: &[[steel_utils::BlockStateId; 3]] = {
            static ORE_VEIN_STATES: std::sync::OnceLock<
                Box<[[steel_utils::BlockStateId; 3]]>,
            > = std::sync::OnceLock::new();
            ORE_VEIN_STATES
                .get_or_init(|| Box::from([
                    [
                        steel_registry::vanilla_blocks::COPPER_ORE.default_state(),
                        steel_registry::vanilla_blocks::RAW_COPPER_BLOCK.default_state(),
                        steel_registry::vanilla_blocks::GRANITE.default_state(),
                    ],
                    [
                        steel_registry::vanilla_blocks::DEEPSLATE_IRON_ORE
                            .default_state(),
                        steel_registry::vanilla_blocks::RAW_IRON_BLOCK.default_state(),
                        steel_registry::vanilla_blocks::TUFF.default_state(),
                    ],
                ]))
        };
        if let Some(state) = ore_veinifier
            .try_apply_material_rule(
                x,
                y,
                z,
                values[0usize],
                values[0usize + 1],
                || {
                    cache.ensure(x, z, self);
                    router_material_ore_vein_0_filler_gap(
                        self,
                        cache,
                        x as f64,
                        y as f64,
                        z as f64,
                    ) as f32
                },
                ore_vein_states[0usize][0],
                ore_vein_states[0usize][1],
                ore_vein_states[0usize][2],
                0.02f32,
            )
        {
            out[0usize] = Some(state);
        }
        if let Some(state) = ore_veinifier
            .try_apply_material_rule(
                x,
                y,
                z,
                values[2usize],
                values[2usize + 1],
                || {
                    cache.ensure(x, z, self);
                    router_material_ore_vein_1_filler_gap(
                        self,
                        cache,
                        x as f64,
                        y as f64,
                        z as f64,
                    ) as f32
                },
                ore_vein_states[1usize][0],
                ore_vein_states[1usize][1],
                ore_vein_states[1usize][2],
                0.02f32,
            )
        {
            out[1usize] = Some(state);
        }
    }
}
impl OverworldNoises {
    /// Apply this dimension's surface rule at the current context position.
    #[allow(
        clippy::collapsible_if,
        clippy::needless_return,
        clippy::erasing_op,
        unused_comparisons
    )]
    fn apply_surface_rule_impl(
        ctx: &mut steel_worldgen::surface::SurfaceRuleContext<'_>,
    ) -> Option<steel_utils::BlockStateId> {
        if ctx
            .system
            .vertical_gradient(
                0usize,
                ctx.block_x,
                ctx.block_y,
                ctx.block_z,
                -64i32,
                -59i32,
            )
        {
            return Some(ctx.block_state(0usize));
        }
        if let Some(state) = ctx.ore_vein_result(0usize) {
            return Some(state);
        }
        if let Some(state) = ctx.ore_vein_result(1usize) {
            return Some(state);
        }
        if ctx.block_y >= ctx.min_surface_level {
            if ctx.stone_depth_above <= 1 + 0i32 {
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::WOODED_BADLANDS,
                            ) as u16
                    })
                {
                    if ctx.block_y >= 97i32 + ctx.surface_depth * 2i32 {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.909f64 && v <= -0.5454f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.1818f64 && v <= 0.1818f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.5454f64 && v <= 0.909f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(2usize));
                        }
                        return Some(ctx.block_state(3usize));
                    }
                }
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::SWAMP,
                            ) as u16
                    })
                {
                    if ctx.block_y >= 62i32 + ctx.surface_depth * 0i32 {
                        if !(ctx.block_y >= 63i32 + ctx.surface_depth * 0i32) {
                            if {
                                let v = ctx.condition_noise(1usize);
                                v >= 0f64
                                    && v
                                        <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                            } {
                                return Some(ctx.block_state(4usize));
                            }
                        }
                    }
                }
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::MANGROVE_SWAMP,
                            ) as u16
                    })
                {
                    if ctx.block_y >= 60i32 + ctx.surface_depth * 0i32 {
                        if !(ctx.block_y >= 63i32 + ctx.surface_depth * 0i32) {
                            if {
                                let v = ctx.condition_noise(1usize);
                                v >= 0f64
                                    && v
                                        <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                            } {
                                return Some(ctx.block_state(4usize));
                            }
                        }
                    }
                }
            }
            if ctx
                .biome_id()
                .is_some_and(|biome_id| {
                    (biome_id
                        == steel_registry::RegistryEntry::id(
                            &*steel_registry::vanilla_biomes::BADLANDS,
                        ) as u16
                        || biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::ERODED_BADLANDS,
                            ) as u16
                        || biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::WOODED_BADLANDS,
                            ) as u16)
                })
            {
                if ctx.stone_depth_above <= 1 + 0i32 {
                    if ctx.block_y >= 256i32 + ctx.surface_depth * 0i32 {
                        return Some(ctx.block_state(5usize));
                    }
                    if ctx.block_y + ctx.stone_depth_above
                        >= 74i32 + ctx.surface_depth * 1i32
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.909f64 && v <= -0.5454f64
                        } {
                            return Some(ctx.block_state(6usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.1818f64 && v <= 0.1818f64
                        } {
                            return Some(ctx.block_state(6usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.5454f64 && v <= 0.909f64
                        } {
                            return Some(ctx.block_state(6usize));
                        }
                        return Some(
                            ctx.system.get_band(ctx.block_x, ctx.block_y, ctx.block_z),
                        );
                    }
                    if ctx.water_height == i32::MIN
                        || ctx.block_y
                            >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                    {
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(7usize));
                        }
                        return Some(ctx.block_state(8usize));
                    }
                    if !(ctx.surface_depth <= 0) {
                        return Some(ctx.block_state(5usize));
                    }
                    if ctx.water_height == i32::MIN
                        || ctx.block_y + ctx.stone_depth_above
                            >= ctx.water_height + -6i32 + ctx.surface_depth * -1i32
                    {
                        return Some(ctx.block_state(9usize));
                    }
                    if ctx.stone_depth_below <= 1 + 0i32 {
                        return Some(ctx.block_state(10usize));
                    }
                    return Some(ctx.block_state(11usize));
                }
                if ctx.block_y + ctx.stone_depth_above
                    >= 63i32 + ctx.surface_depth * -1i32
                {
                    if ctx.block_y >= 63i32 + ctx.surface_depth * 0i32 {
                        if !(ctx.block_y + ctx.stone_depth_above
                            >= 74i32 + ctx.surface_depth * 1i32)
                        {
                            return Some(ctx.block_state(5usize));
                        }
                    }
                    return Some(
                        ctx.system.get_band(ctx.block_x, ctx.block_y, ctx.block_z),
                    );
                }
                if ctx.stone_depth_above <= 1 + 0i32 + ctx.surface_depth {
                    if ctx.water_height == i32::MIN
                        || ctx.block_y + ctx.stone_depth_above
                            >= ctx.water_height + -6i32 + ctx.surface_depth * -1i32
                    {
                        return Some(ctx.block_state(9usize));
                    }
                }
            }
            if ctx.stone_depth_above <= 1 + 0i32 {
                if ctx.water_height == i32::MIN
                    || ctx.block_y >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                {
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            (biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::FROZEN_OCEAN,
                                ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::DEEP_FROZEN_OCEAN,
                                    ) as u16)
                        })
                    {
                        if ctx.surface_depth <= 0 {
                            return Some(ctx.block_state(12usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::FROZEN_PEAKS,
                                ) as u16
                        })
                    {
                        if ctx.steep {
                            return Some(ctx.block_state(13usize));
                        }
                        if {
                            let v = ctx.condition_noise(2usize);
                            v >= 0f64 && v <= 0.2f64
                        } {
                            return Some(ctx.block_state(13usize));
                        }
                        if {
                            let v = ctx.condition_noise(3usize);
                            v >= 0f64 && v <= 0.025f64
                        } {
                            return Some(ctx.block_state(14usize));
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::SNOWY_SLOPES,
                                ) as u16
                        })
                    {
                        if ctx.steep {
                            return Some(ctx.block_state(10usize));
                        }
                        if {
                            let v = ctx.condition_noise(4usize);
                            v >= 0.35f64 && v <= 0.6f64
                        } {
                            if ctx.water_height == i32::MIN
                                || ctx.block_y
                                    >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                            {
                                return Some(ctx.block_state(16usize));
                            }
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::JAGGED_PEAKS,
                                ) as u16
                        })
                    {
                        if ctx.steep {
                            return Some(ctx.block_state(10usize));
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::GROVE,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(4usize);
                            v >= 0.35f64 && v <= 0.6f64
                        } {
                            if ctx.water_height == i32::MIN
                                || ctx.block_y
                                    >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                            {
                                return Some(ctx.block_state(16usize));
                            }
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::STONY_PEAKS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(5usize);
                            v >= -0.0125f64 && v <= 0.0125f64
                        } {
                            return Some(ctx.block_state(17usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::STONY_SHORE,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(6usize);
                            v >= -0.05f64 && v <= 0.05f64
                        } {
                            if ctx.stone_depth_below <= 1 + 0i32 {
                                return Some(ctx.block_state(10usize));
                            }
                            return Some(ctx.block_state(11usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_HILLS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            (biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WARM_OCEAN,
                                ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::BEACH,
                                    ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::SNOWY_BEACH,
                                    ) as u16)
                        })
                    {
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(18usize));
                        }
                        return Some(ctx.block_state(19usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DESERT,
                                ) as u16
                        })
                    {
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(18usize));
                        }
                        return Some(ctx.block_state(19usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DRIPSTONE_CAVES,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::SULFUR_CAVES,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= -0.4000000059604645f64 && v <= -0.10000000149011612f64
                        } {
                            return Some(ctx.block_state(20usize));
                        }
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= 0f64 && v <= 0.4000000059604645f64
                        } {
                            return Some(ctx.block_state(21usize));
                        }
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= 0.4000000059604645f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(20usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::MANGROVE_SWAMP,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(22usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_SAVANNA,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.21212121212121213f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.06060606060606061f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_GRAVELLY_HILLS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.24242424242424243f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            if ctx.stone_depth_below <= 1 + 0i32 {
                                return Some(ctx.block_state(10usize));
                            }
                            return Some(ctx.block_state(11usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            if ctx.water_height == i32::MIN
                                || ctx.block_y
                                    >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                            {
                                return Some(ctx.block_state(2usize));
                            }
                            return Some(ctx.block_state(3usize));
                        }
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(10usize));
                        }
                        return Some(ctx.block_state(11usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            (biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::OLD_GROWTH_PINE_TAIGA,
                                ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::OLD_GROWTH_SPRUCE_TAIGA,
                                    ) as u16)
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.21212121212121213f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.11515151515151514f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(23usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::ICE_SPIKES,
                                ) as u16
                        })
                    {
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::MUSHROOM_FIELDS,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(24usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DAPPLED_FOREST,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(8usize);
                            v >= 1.2000000476837158f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(1usize));
                        }
                    }
                    if ctx.water_height == i32::MIN
                        || ctx.block_y
                            >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                    {
                        return Some(ctx.block_state(2usize));
                    }
                    return Some(ctx.block_state(3usize));
                }
            }
            if ctx.water_height == i32::MIN
                || ctx.block_y + ctx.stone_depth_above
                    >= ctx.water_height + -6i32 + ctx.surface_depth * -1i32
            {
                if ctx.stone_depth_above <= 1 + 0i32 {
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            (biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::FROZEN_OCEAN,
                                ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::DEEP_FROZEN_OCEAN,
                                    ) as u16)
                        })
                    {
                        if ctx.surface_depth <= 0 {
                            return Some(ctx.block_state(4usize));
                        }
                    }
                }
                if ctx.stone_depth_above <= 1 + 0i32 + ctx.surface_depth {
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::FROZEN_PEAKS,
                                ) as u16
                        })
                    {
                        if ctx.steep {
                            return Some(ctx.block_state(13usize));
                        }
                        if {
                            let v = ctx.condition_noise(2usize);
                            v >= -0.5f64 && v <= 0.2f64
                        } {
                            return Some(ctx.block_state(13usize));
                        }
                        if {
                            let v = ctx.condition_noise(3usize);
                            v >= -0.0625f64 && v <= 0.025f64
                        } {
                            return Some(ctx.block_state(14usize));
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::SNOWY_SLOPES,
                                ) as u16
                        })
                    {
                        if ctx.steep {
                            return Some(ctx.block_state(10usize));
                        }
                        if {
                            let v = ctx.condition_noise(4usize);
                            v >= 0.45f64 && v <= 0.58f64
                        } {
                            if ctx.water_height == i32::MIN
                                || ctx.block_y
                                    >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                            {
                                return Some(ctx.block_state(16usize));
                            }
                        }
                        if ctx.water_height == i32::MIN
                            || ctx.block_y
                                >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                        {
                            return Some(ctx.block_state(15usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::JAGGED_PEAKS,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::GROVE,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(4usize);
                            v >= 0.45f64 && v <= 0.58f64
                        } {
                            if ctx.water_height == i32::MIN
                                || ctx.block_y
                                    >= ctx.water_height + -1i32 + ctx.surface_depth * 0i32
                            {
                                return Some(ctx.block_state(16usize));
                            }
                        }
                        return Some(ctx.block_state(3usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::STONY_PEAKS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(5usize);
                            v >= -0.0125f64 && v <= 0.0125f64
                        } {
                            return Some(ctx.block_state(17usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::STONY_SHORE,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(6usize);
                            v >= -0.05f64 && v <= 0.05f64
                        } {
                            if ctx.stone_depth_below <= 1 + 0i32 {
                                return Some(ctx.block_state(10usize));
                            }
                            return Some(ctx.block_state(11usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_HILLS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            (biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WARM_OCEAN,
                                ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::BEACH,
                                    ) as u16
                                || biome_id
                                    == steel_registry::RegistryEntry::id(
                                        &*steel_registry::vanilla_biomes::SNOWY_BEACH,
                                    ) as u16)
                        })
                    {
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(18usize));
                        }
                        return Some(ctx.block_state(19usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DESERT,
                                ) as u16
                        })
                    {
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(18usize));
                        }
                        return Some(ctx.block_state(19usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DRIPSTONE_CAVES,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::SULFUR_CAVES,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= -0.4000000059604645f64 && v <= -0.10000000149011612f64
                        } {
                            return Some(ctx.block_state(20usize));
                        }
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= 0f64 && v <= 0.4000000059604645f64
                        } {
                            return Some(ctx.block_state(21usize));
                        }
                        if {
                            let v = ctx.condition_noise_3d(7usize);
                            v >= 0.4000000059604645f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(20usize));
                        }
                        return Some(ctx.block_state(10usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::MANGROVE_SWAMP,
                                ) as u16
                        })
                    {
                        return Some(ctx.block_state(22usize));
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_SAVANNA,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.21212121212121213f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                    }
                    if ctx
                        .biome_id()
                        .is_some_and(|biome_id| {
                            biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::WINDSWEPT_GRAVELLY_HILLS,
                                ) as u16
                        })
                    {
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.24242424242424243f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            if ctx.stone_depth_below <= 1 + 0i32 {
                                return Some(ctx.block_state(10usize));
                            }
                            return Some(ctx.block_state(11usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= 0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(10usize));
                        }
                        if {
                            let v = ctx.condition_noise(0usize);
                            v >= -0.12121212121212122f64
                                && v
                                    <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
                        } {
                            return Some(ctx.block_state(3usize));
                        }
                        if ctx.stone_depth_below <= 1 + 0i32 {
                            return Some(ctx.block_state(10usize));
                        }
                        return Some(ctx.block_state(11usize));
                    }
                    return Some(ctx.block_state(3usize));
                }
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        (biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::WARM_OCEAN,
                            ) as u16
                            || biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::BEACH,
                                ) as u16
                            || biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::SNOWY_BEACH,
                                ) as u16)
                    })
                {
                    if {
                        let extra = ((ctx.surface_secondary + 1.0) / 2.0 * 6i32 as f64)
                            as i32;
                        ctx.stone_depth_above <= 1 + 0i32 + ctx.surface_depth + extra
                    } {
                        return Some(ctx.block_state(18usize));
                    }
                }
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::DESERT,
                            ) as u16
                    })
                {
                    if {
                        let extra = ((ctx.surface_secondary + 1.0) / 2.0 * 30i32 as f64)
                            as i32;
                        ctx.stone_depth_above <= 1 + 0i32 + ctx.surface_depth + extra
                    } {
                        return Some(ctx.block_state(18usize));
                    }
                }
            }
            if ctx.stone_depth_above <= 1 + 0i32 {
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        (biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::FROZEN_PEAKS,
                            ) as u16
                            || biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::JAGGED_PEAKS,
                                ) as u16)
                    })
                {
                    return Some(ctx.block_state(10usize));
                }
                if ctx
                    .biome_id()
                    .is_some_and(|biome_id| {
                        (biome_id
                            == steel_registry::RegistryEntry::id(
                                &*steel_registry::vanilla_biomes::WARM_OCEAN,
                            ) as u16
                            || biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::LUKEWARM_OCEAN,
                                ) as u16
                            || biome_id
                                == steel_registry::RegistryEntry::id(
                                    &*steel_registry::vanilla_biomes::DEEP_LUKEWARM_OCEAN,
                                ) as u16)
                    })
                {
                    if ctx.stone_depth_below <= 1 + 0i32 {
                        return Some(ctx.block_state(18usize));
                    }
                    return Some(ctx.block_state(19usize));
                }
                if ctx.stone_depth_below <= 1 + 0i32 {
                    return Some(ctx.block_state(10usize));
                }
                return Some(ctx.block_state(11usize));
            }
        }
        if ctx
            .biome_id()
            .is_some_and(|biome_id| {
                biome_id
                    == steel_registry::RegistryEntry::id(
                        &*steel_registry::vanilla_biomes::SULFUR_CAVES,
                    ) as u16
            })
        {
            if {
                let v = ctx.condition_noise_3d(7usize);
                v >= -0.4000000059604645f64 && v <= -0.10000000149011612f64
            } {
                return Some(ctx.block_state(20usize));
            }
            if {
                let v = ctx.condition_noise_3d(7usize);
                v >= 0f64 && v <= 0.4000000059604645f64
            } {
                return Some(ctx.block_state(21usize));
            }
            if {
                let v = ctx.condition_noise_3d(7usize);
                v >= 0.4000000059604645f64
                    && v
                        <= 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f64
            } {
                return Some(ctx.block_state(20usize));
            }
        }
        if ctx
            .system
            .vertical_gradient(1usize, ctx.block_x, ctx.block_y, ctx.block_z, 0i32, 8i32)
        {
            return Some(ctx.block_state(25usize));
        }
        None
    }
}