Fixes

14 files changed, 5108 insertions, 196 deletions

diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
index a0001804..e63c9b07 100755
--- a/azalea-client/src/connect.rs
+++ b/azalea-client/src/connect.rs
@@ -12,7 +12,8 @@ use azalea_protocol::{
         handshake::client_intention_packet::ClientIntentionPacket,
         login::{
             serverbound_hello_packet::ServerboundHelloPacket,
-            serverbound_key_packet::ServerboundKeyPacket, LoginPacket,
+            serverbound_key_packet::{NonceOrSaltSignature, ServerboundKeyPacket},
+            LoginPacket,
         },
         ConnectionProtocol, PROTOCOL_VERSION,
     },
@@ -109,8 +110,10 @@ impl Client {
 
                         conn.write(
                             ServerboundKeyPacket {
-                                nonce: e.encrypted_nonce,
-                                shared_secret: e.encrypted_public_key,
+                                nonce_or_salt_signature: NonceOrSaltSignature::Nonce(
+                                    e.encrypted_nonce,
+                                ),
+                                key_bytes: e.encrypted_public_key,
                             }
                             .get(),
                         )
@@ -196,27 +199,66 @@ impl Client {
                 println!("Got login packet {:?}", p);
 
                 let mut state = state.lock().await;
+
+                // write p into login.txt
+                std::io::Write::write_all(
+                    &mut std::fs::File::create("login.txt").unwrap(),
+                    format!("{:#?}", p).as_bytes(),
+                )
+                .unwrap();
+
                 state.player.entity.id = p.player_id;
-                let dimension_type = p
-                    .dimension_type
+
+                // TODO: have registry_holder be a struct because this sucks rn
+                // best way would be to add serde support to azalea-nbt
+
+                let registry_holder = p
+                    .registry_holder
                     .as_compound()
-                    .expect("Dimension type is not compound")
+                    .expect("Registry holder is not a compound")
                     .get("")
                     .expect("No \"\" tag")
                     .as_compound()
-                    .expect("\"\" tag is not compound");
+                    .expect("\"\" tag is not a compound");
+                let dimension_types = registry_holder
+                    .get("minecraft:dimension_type")
+                    .expect("No dimension_type tag")
+                    .as_compound()
+                    .expect("dimension_type is not a compound")
+                    .get("value")
+                    .expect("No dimension_type value")
+                    .as_list()
+                    .expect("dimension_type value is not a list");
+                let dimension_type = dimension_types
+                    .iter()
+                    .find(|t| {
+                        t.as_compound()
+                            .expect("dimension_type value is not a compound")
+                            .get("name")
+                            .expect("No name tag")
+                            .as_string()
+                            .expect("name is not a string")
+                            == p.dimension_type.to_string()
+                    })
+                    .expect(&format!("No dimension_type with name {}", p.dimension_type))
+                    .as_compound()
+                    .unwrap()
+                    .get("element")
+                    .expect("No element tag")
+                    .as_compound()
+                    .expect("element is not a compound");
                 let height = (*dimension_type
                     .get("height")
                     .expect("No height tag")
                     .as_int()
-                    .expect("height tag is not int"))
+                    .expect("height tag is not an int"))
                 .try_into()
                 .expect("height is not a u32");
                 let min_y = (*dimension_type
                     .get("min_y")
                     .expect("No min_y tag")
                     .as_int()
-                    .expect("min_y tag is not int"))
+                    .expect("min_y tag is not an int"))
                 .try_into()
                 .expect("min_y is not an i32");
 
diff --git a/azalea-core/src/lib.rs b/azalea-core/src/lib.rs
index d2a2d558..cdb32ea9 100755
--- a/azalea-core/src/lib.rs
+++ b/azalea-core/src/lib.rs
@@ -11,7 +11,9 @@ mod slot;
 pub use slot::{Slot, SlotData};
 
 mod position;
-pub use position::{BlockPos, ChunkBlockPos, ChunkPos, ChunkSectionBlockPos, ChunkSectionPos};
+pub use position::{
+    BlockPos, ChunkBlockPos, ChunkPos, ChunkSectionBlockPos, ChunkSectionPos, GlobalPos,
+};
 
 mod direction;
 pub use direction::Direction;
diff --git a/azalea-core/src/position.rs b/azalea-core/src/position.rs
index 9c7cd132..d5c97eab 100644
--- a/azalea-core/src/position.rs
+++ b/azalea-core/src/position.rs
@@ -1,5 +1,7 @@
 use std::ops::Rem;
 
+use crate::resource_location::ResourceLocation;
+
 #[derive(Clone, Copy, Debug, Default)]
 pub struct BlockPos {
     pub x: i32,
@@ -137,6 +139,14 @@ impl From<&ChunkBlockPos> for ChunkSectionBlockPos {
     }
 }
 
+/// A block pos with an attached dimension
+#[derive(Debug, Clone)]
+pub struct GlobalPos {
+    pub pos: BlockPos,
+    // this is actually a ResourceKey in Minecraft, but i don't think it matters?
+    pub dimension: ResourceLocation,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/azalea-nbt/README.md b/azalea-nbt/README.md
index 19498cf3..4d5cecc4 100755
--- a/azalea-nbt/README.md
+++ b/azalea-nbt/README.md
@@ -1,3 +1,5 @@
 # Azalea NBT
 
 A fast NBT serializer and deserializer.
+
+TODO: serde support for fast registry_holder parsing in azalea-client
diff --git a/azalea-nbt/src/error.rs b/azalea-nbt/src/error.rs
index 219921e4..ef4a9e9f 100755
--- a/azalea-nbt/src/error.rs
+++ b/azalea-nbt/src/error.rs
@@ -2,7 +2,8 @@
 pub enum Error {
     InvalidTagType(u8),
     InvalidTag,
-    WriteError,
+    WriteError(std::io::Error),
+    Utf8Error(std::string::FromUtf8Error),
 }
 
 impl std::fmt::Display for Error {
@@ -10,18 +11,19 @@ impl std::fmt::Display for Error {
         match self {
             Error::InvalidTagType(id) => write!(f, "Invalid tag type: {}", id),
             Error::InvalidTag => write!(f, "Invalid tag"),
-            Error::WriteError => write!(f, "Write error"),
+            Error::WriteError(e) => write!(f, "Write error: {}", e),
+            Error::Utf8Error(e) => write!(f, "Utf8 error: {}", e),
         }
     }
 }
 
 impl From<std::io::Error> for Error {
-    fn from(_: std::io::Error) -> Self {
-        Error::WriteError
+    fn from(e: std::io::Error) -> Self {
+        Error::WriteError(e)
     }
 }
 impl From<std::string::FromUtf8Error> for Error {
-    fn from(_: std::string::FromUtf8Error) -> Self {
-        Error::WriteError
+    fn from(e: std::string::FromUtf8Error) -> Self {
+        Error::Utf8Error(e)
     }
 }
diff --git a/azalea-protocol/packet-macros/src/lib.rs b/azalea-protocol/packet-macros/src/lib.rs
index f3fe4e40..ae0fea0c 100755
--- a/azalea-protocol/packet-macros/src/lib.rs
+++ b/azalea-protocol/packet-macros/src/lib.rs
@@ -56,13 +56,23 @@ fn create_impl_mcbufreadable(ident: &Ident, data: &Data) -> proc_macro2::TokenSt
         }
         syn::Data::Enum(syn::DataEnum { variants, .. }) => {
             let mut match_contents = quote!();
+            let mut variant_discrim: usize = 0;
             for variant in variants {
                 let variant_name = &variant.ident;
-                let variant_discrim = &variant
-                    .discriminant
-                    .as_ref()
-                    .expect("enum variant must have a discriminant")
-                    .1;
+                match &variant.discriminant.as_ref() {
+                    Some(d) => {
+                        variant_discrim = match &d.1 {
+                            syn::Expr::Lit(e) => match &e.lit {
+                                syn::Lit::Int(i) => i.base10_parse().unwrap(),
+                                _ => panic!("Error parsing enum discriminant"),
+                            },
+                            _ => panic!("Error parsing enum discriminant"),
+                        }
+                    }
+                    None => {
+                        variant_discrim += 1;
+                    }
+                }
                 match_contents.extend(quote! {
                     #variant_discrim => Ok(Self::#variant_name),
                 });
@@ -344,6 +354,7 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream {
         });
     }
     for PacketIdPair { id, module, name } in input.clientbound.packets {
+        let name_litstr = syn::LitStr::new(&name.to_string(), name.span());
         enum_contents.extend(quote! {
             #name(#module::#name),
         });
@@ -354,7 +365,10 @@ pub fn declare_state_packets(input: TokenStream) -> TokenStream {
             #state_name::#name(packet) => packet.write(buf),
         });
         clientbound_read_match_contents.extend(quote! {
-            #id => #module::#name::read(buf)?,
+            #id => {
+                println!("reading packet {}", #name_litstr);
+                #module::#name::read(buf)?
+            },
         });
     }
 
diff --git a/azalea-protocol/src/lib.rs b/azalea-protocol/src/lib.rs
index 3573894c..d7f75f00 100755
--- a/azalea-protocol/src/lib.rs
+++ b/azalea-protocol/src/lib.rs
@@ -1,6 +1,7 @@
 //! This lib is responsible for parsing Minecraft packets.
 
 #![feature(min_specialization)]
+#![feature(arbitrary_enum_discriminant)]
 
 use std::net::IpAddr;
 use std::str::FromStr;
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index 350c0998..7cb0bb09 100644
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -2,7 +2,8 @@ use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
-    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, Slot, SlotData,
+    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, GlobalPos, Slot,
+    SlotData,
 };
 use azalea_crypto::SaltSignaturePair;
 use byteorder::{ReadBytesExt, BE};
@@ -481,6 +482,15 @@ impl McBufReadable for BlockPos {
     }
 }
 
+impl McBufReadable for GlobalPos {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        Ok(GlobalPos {
+            pos: BlockPos::read_into(buf)?,
+            dimension: ResourceLocation::read_into(buf)?,
+        })
+    }
+}
+
 impl McBufReadable for Direction {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         match buf.read_varint()? {
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index 95c39bd2..80ffaecd 100644
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -2,7 +2,7 @@ use super::{UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
-    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, Slot,
+    serializable_uuid::SerializableUuid, BlockPos, ChunkSectionPos, Direction, GlobalPos, Slot,
 };
 use azalea_crypto::SaltSignaturePair;
 use byteorder::{BigEndian, WriteBytesExt};
@@ -193,28 +193,24 @@ impl McBufWritable for Vec<u8> {
     }
 }
 
-// string
 impl McBufWritable for String {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_utf(self)
     }
 }
 
-// ResourceLocation
 impl McBufWritable for ResourceLocation {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_resource_location(self)
     }
 }
 
-// u32
 impl McBufWritable for u32 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
-// u32 varint
 impl McBufVarWritable for u32 {
     fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::var_write_into(&(*self as i32), buf)
@@ -244,21 +240,18 @@ impl McBufVarWritable for u64 {
     }
 }
 
-// u16
 impl McBufWritable for u16 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i16::write_into(&(*self as i16), buf)
     }
 }
 
-// u16 varint
 impl McBufVarWritable for u16 {
     fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i32::var_write_into(&(*self as i32), buf)
     }
 }
 
-// Vec<T> varint
 impl<T: McBufVarWritable> McBufVarWritable for Vec<T> {
     fn var_write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u32::var_write_into(&(self.len() as u32), buf)?;
@@ -269,77 +262,66 @@ impl<T: McBufVarWritable> McBufVarWritable for Vec<T> {
     }
 }
 
-// u8
 impl McBufWritable for u8 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self)
     }
 }
 
-// i16
 impl McBufWritable for i16 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_short(buf, *self)
     }
 }
 
-// i64
 impl McBufWritable for i64 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         Writable::write_long(buf, *self)
     }
 }
 
-// u64
 impl McBufWritable for u64 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         i64::write_into(&(*self as i64), buf)
     }
 }
 
-// bool
 impl McBufWritable for bool {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_boolean(*self)
     }
 }
 
-// i8
 impl McBufWritable for i8 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(*self as u8)
     }
 }
 
-// f32
 impl McBufWritable for f32 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_float(*self)
     }
 }
 
-// f64
 impl McBufWritable for f64 {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_double(*self)
     }
 }
 
-// GameType
 impl McBufWritable for GameType {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.to_id(), buf)
     }
 }
 
-// Option<GameType>
 impl McBufWritable for Option<GameType> {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_byte(GameType::to_optional_id(self) as u8)
     }
 }
 
-// Option<String>
 impl<T: McBufWritable> McBufWritable for Option<T> {
     default fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         if let Some(s) = self {
@@ -352,21 +334,18 @@ impl<T: McBufWritable> McBufWritable for Option<T> {
     }
 }
 
-// azalea_nbt::Tag
 impl McBufWritable for azalea_nbt::Tag {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_nbt(self)
     }
 }
 
-// Difficulty
 impl McBufWritable for Difficulty {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         u8::write_into(&self.id(), buf)
     }
 }
 
-// Component
 impl McBufWritable for Component {
     // async fn read_into(buf: &mut impl Read) -> Result<Self, String>
     // where
@@ -384,7 +363,6 @@ impl McBufWritable for Component {
     }
 }
 
-// Slot
 impl McBufWritable for Slot {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         match self {
@@ -400,7 +378,6 @@ impl McBufWritable for Slot {
     }
 }
 
-// Slot
 impl McBufWritable for Uuid {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_uuid(self)?;
@@ -409,7 +386,6 @@ impl McBufWritable for Uuid {
     }
 }
 
-// BlockPos
 impl McBufWritable for BlockPos {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_long(
@@ -420,14 +396,21 @@ impl McBufWritable for BlockPos {
     }
 }
 
-// Direction
+impl McBufWritable for GlobalPos {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        BlockPos::write_into(&self.pos, buf)?;
+        ResourceLocation::write_into(&self.dimension, buf)?;
+
+        Ok(())
+    }
+}
+
 impl McBufWritable for Direction {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         buf.write_varint(*self as i32)
     }
 }
 
-// ChunkSectionPos
 impl McBufWritable for ChunkSectionPos {
     fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
         let long = (((self.x & 0x3FFFFF) as i64) << 42)
diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
index 6743c3af..01f633f4 100755
--- a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
@@ -1,6 +1,7 @@
 use super::GamePacket;
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::resource_location::ResourceLocation;
+use packet_macros::McBuf;
 use std::{
     hash::Hash,
     io::{Read, Write},
@@ -110,6 +111,58 @@ impl McBufWritable for BrigadierString {
     }
 }
 
+#[derive(Debug, Clone, McBuf)]
+pub enum BrigadierParserType {
+    Bool = 0,
+    Double,
+    Float,
+    Integer,
+    Long,
+    String,
+    Entity,
+    GameProfile,
+    BlockPos,
+    ColumnPos,
+    Vec3,
+    Vec2,
+    BlockState,
+    BlockPredicate,
+    ItemStack,
+    ItemPredicate,
+    Color,
+    Component,
+    Message,
+    Nbt,
+    NbtPath,
+    Objective,
+    ObjectiveCriteira,
+    Operation,
+    Particle,
+    Rotation,
+    Angle,
+    ScoreboardSlot,
+    ScoreHolder,
+    Swizzle,
+    Team,
+    ItemSlot,
+    ResourceLocation,
+    MobEffect,
+    Function,
+    EntityAnchor,
+    Range,
+    IntRange,
+    FloatRange,
+    ItemEnchantment,
+    EntitySummon,
+    Dimension,
+    Uuid,
+    NbtTag,
+    NbtCompoundTag,
+    Time,
+    ResourceOrTag,
+    Resource,
+}
+
 #[derive(Debug, Clone)]
 pub enum BrigadierParser {
     Bool,
@@ -164,119 +217,84 @@ pub enum BrigadierParser {
 
 impl McBufReadable for BrigadierParser {
     fn read_into(buf: &mut impl Read) -> Result<Self, String> {
-        let parser = buf.read_resource_location()?;
+        let parser_type = BrigadierParserType::read_into(buf)?;
 
-        if parser == ResourceLocation::new("brigadier:bool")? {
-            Ok(BrigadierParser::Bool)
-        } else if parser == ResourceLocation::new("brigadier:double")? {
-            Ok(BrigadierParser::Double(BrigadierNumber::read_into(buf)?))
-        } else if parser == ResourceLocation::new("brigadier:float")? {
-            Ok(BrigadierParser::Float(BrigadierNumber::read_into(buf)?))
-        } else if parser == ResourceLocation::new("brigadier:integer")? {
-            Ok(BrigadierParser::Integer(BrigadierNumber::read_into(buf)?))
-        } else if parser == ResourceLocation::new("brigadier:long")? {
-            Ok(BrigadierParser::Long(BrigadierNumber::read_into(buf)?))
-        } else if parser == ResourceLocation::new("brigadier:string")? {
-            Ok(BrigadierParser::String(BrigadierString::read_into(buf)?))
-        } else if parser == ResourceLocation::new("minecraft:entity")? {
-            let flags = buf.read_byte()?;
-            Ok(BrigadierParser::Entity {
-                single: flags & 0x01 != 0,
-                players_only: flags & 0x02 != 0,
-            })
-        } else if parser == ResourceLocation::new("minecraft:game_profile")? {
-            Ok(BrigadierParser::GameProfile)
-        } else if parser == ResourceLocation::new("minecraft:block_pos")? {
-            Ok(BrigadierParser::BlockPos)
-        } else if parser == ResourceLocation::new("minecraft:column_pos")? {
-            Ok(BrigadierParser::ColumnPos)
-        } else if parser == ResourceLocation::new("minecraft:vec3")? {
-            Ok(BrigadierParser::Vec3)
-        } else if parser == ResourceLocation::new("minecraft:vec2")? {
-            Ok(BrigadierParser::Vec2)
-        } else if parser == ResourceLocation::new("minecraft:block_state")? {
-            Ok(BrigadierParser::BlockState)
-        } else if parser == ResourceLocation::new("minecraft:block_predicate")? {
-            Ok(BrigadierParser::BlockPredicate)
-        } else if parser == ResourceLocation::new("minecraft:item_stack")? {
-            Ok(BrigadierParser::ItemStack)
-        } else if parser == ResourceLocation::new("minecraft:item_predicate")? {
-            Ok(BrigadierParser::ItemPredicate)
-        } else if parser == ResourceLocation::new("minecraft:color")? {
-            Ok(BrigadierParser::Color)
-        } else if parser == ResourceLocation::new("minecraft:component")? {
-            Ok(BrigadierParser::Component)
-        } else if parser == ResourceLocation::new("minecraft:message")? {
-            Ok(BrigadierParser::Message)
-        } else if parser == ResourceLocation::new("minecraft:nbt")? {
-            Ok(BrigadierParser::Nbt)
-        } else if parser == ResourceLocation::new("minecraft:nbt_path")? {
-            Ok(BrigadierParser::NbtPath)
-        } else if parser == ResourceLocation::new("minecraft:objective")? {
-            Ok(BrigadierParser::Objective)
-        } else if parser == ResourceLocation::new("minecraft:objective_criteria")? {
-            Ok(BrigadierParser::ObjectiveCriteira)
-        } else if parser == ResourceLocation::new("minecraft:operation")? {
-            Ok(BrigadierParser::Operation)
-        } else if parser == ResourceLocation::new("minecraft:particle")? {
-            Ok(BrigadierParser::Particle)
-        } else if parser == ResourceLocation::new("minecraft:rotation")? {
-            Ok(BrigadierParser::Rotation)
-        } else if parser == ResourceLocation::new("minecraft:angle")? {
-            Ok(BrigadierParser::Angle)
-        } else if parser == ResourceLocation::new("minecraft:scoreboard_slot")? {
-            Ok(BrigadierParser::ScoreboardSlot)
-        } else if parser == ResourceLocation::new("minecraft:score_holder")? {
-            let flags = buf.read_byte()?;
-            Ok(BrigadierParser::ScoreHolder {
-                allows_multiple: flags & 0x01 != 0,
-            })
-        } else if parser == ResourceLocation::new("minecraft:swizzle")? {
-            Ok(BrigadierParser::Swizzle)
-        } else if parser == ResourceLocation::new("minecraft:team")? {
-            Ok(BrigadierParser::Team)
-        } else if parser == ResourceLocation::new("minecraft:item_slot")? {
-            Ok(BrigadierParser::ItemSlot)
-        } else if parser == ResourceLocation::new("minecraft:resource_location")? {
-            Ok(BrigadierParser::ResourceLocation)
-        } else if parser == ResourceLocation::new("minecraft:mob_effect")? {
-            Ok(BrigadierParser::MobEffect)
-        } else if parser == ResourceLocation::new("minecraft:function")? {
-            Ok(BrigadierParser::Function)
-        } else if parser == ResourceLocation::new("minecraft:entity_anchor")? {
-            Ok(BrigadierParser::EntityAnchor)
-        } else if parser == ResourceLocation::new("minecraft:range")? {
-            Ok(BrigadierParser::Range {
+        match parser_type {
+            BrigadierParserType::Bool => Ok(BrigadierParser::Bool),
+            BrigadierParserType::Double => {
+                Ok(BrigadierParser::Double(BrigadierNumber::read_into(buf)?))
+            }
+            BrigadierParserType::Float => {
+                Ok(BrigadierParser::Float(BrigadierNumber::read_into(buf)?))
+            }
+            BrigadierParserType::Integer => {
+                Ok(BrigadierParser::Integer(BrigadierNumber::read_into(buf)?))
+            }
+            BrigadierParserType::Long => {
+                Ok(BrigadierParser::Long(BrigadierNumber::read_into(buf)?))
+            }
+            BrigadierParserType::String => {
+                Ok(BrigadierParser::String(BrigadierString::read_into(buf)?))
+            }
+            BrigadierParserType::Entity {
+                single,
+                players_only,
+            } => Ok(BrigadierParser::Entity {
+                single,
+                players_only,
+            }),
+            BrigadierParserType::GameProfile => Ok(BrigadierParser::GameProfile),
+            BrigadierParserType::BlockPos => Ok(BrigadierParser::BlockPos),
+            BrigadierParserType::ColumnPos => Ok(BrigadierParser::ColumnPos),
+            BrigadierParserType::Vec3 => Ok(BrigadierParser::Vec3),
+            BrigadierParserType::Vec2 => Ok(BrigadierParser::Vec2),
+            BrigadierParserType::BlockState => Ok(BrigadierParser::BlockState),
+            BrigadierParserType::BlockPredicate => Ok(BrigadierParser::BlockPredicate),
+            BrigadierParserType::ItemStack => Ok(BrigadierParser::ItemStack),
+            BrigadierParserType::ItemPredicate => Ok(BrigadierParser::ItemPredicate),
+            BrigadierParserType::Color => Ok(BrigadierParser::Color),
+            BrigadierParserType::Component => Ok(BrigadierParser::Component),
+            BrigadierParserType::Message => Ok(BrigadierParser::Message),
+            BrigadierParserType::Nbt => Ok(BrigadierParser::Nbt),
+            BrigadierParserType::NbtPath => Ok(BrigadierParser::NbtPath),
+            BrigadierParserType::Objective => Ok(BrigadierParser::Objective),
+            BrigadierParserType::ObjectiveCriteira => Ok(BrigadierParser::ObjectiveCriteira),
+            BrigadierParserType::Operation => Ok(BrigadierParser::Operation),
+            BrigadierParserType::Particle => Ok(BrigadierParser::Particle),
+            BrigadierParserType::Rotation => Ok(BrigadierParser::Rotation),
+            BrigadierParserType::Angle => Ok(BrigadierParser::Angle),
+            BrigadierParserType::ScoreboardSlot => Ok(BrigadierParser::ScoreboardSlot),
+            BrigadierParserType::ScoreHolder => {
+                let flags = buf.read_byte()?;
+                Ok(BrigadierParser::ScoreHolder {
+                    allows_multiple: flags & 0x01 != 0,
+                })
+            }
+            BrigadierParserType::Swizzle => Ok(BrigadierParser::Swizzle),
+            BrigadierParserType::Team => Ok(BrigadierParser::Team),
+            BrigadierParserType::ItemSlot => Ok(BrigadierParser::ItemSlot),
+            BrigadierParserType::ResourceLocation => Ok(BrigadierParser::ResourceLocation),
+            BrigadierParserType::MobEffect => Ok(BrigadierParser::MobEffect),
+            BrigadierParserType::Function => Ok(BrigadierParser::Function),
+            BrigadierParserType::EntityAnchor => Ok(BrigadierParser::EntityAnchor),
+            BrigadierParserType::Range => Ok(BrigadierParser::Range {
                 decimals_allowed: buf.read_boolean()?,
-            })
-        } else if parser == ResourceLocation::new("minecraft:int_range")? {
-            Ok(BrigadierParser::IntRange)
-        } else if parser == ResourceLocation::new("minecraft:float_range")? {
-            Ok(BrigadierParser::FloatRange)
-        } else if parser == ResourceLocation::new("minecraft:item_enchantment")? {
-            Ok(BrigadierParser::ItemEnchantment)
-        } else if parser == ResourceLocation::new("minecraft:entity_summon")? {
-            Ok(BrigadierParser::EntitySummon)
-        } else if parser == ResourceLocation::new("minecraft:dimension")? {
-            Ok(BrigadierParser::Dimension)
-        } else if parser == ResourceLocation::new("minecraft:uuid")? {
-            Ok(BrigadierParser::Uuid)
-        } else if parser == ResourceLocation::new("minecraft:nbt_tag")? {
-            Ok(BrigadierParser::NbtTag)
-        } else if parser == ResourceLocation::new("minecraft:nbt_compound_tag")? {
-            Ok(BrigadierParser::NbtCompoundTag)
-        } else if parser == ResourceLocation::new("minecraft:time")? {
-            Ok(BrigadierParser::Time)
-        } else if parser == ResourceLocation::new("minecraft:resource_or_tag")? {
-            Ok(BrigadierParser::ResourceOrTag {
+            }),
+            BrigadierParserType::IntRange => Ok(BrigadierParser::IntRange),
+            BrigadierParserType::FloatRange => Ok(BrigadierParser::FloatRange),
+            BrigadierParserType::ItemEnchantment => Ok(BrigadierParser::ItemEnchantment),
+            BrigadierParserType::EntitySummon => Ok(BrigadierParser::EntitySummon),
+            BrigadierParserType::Dimension => Ok(BrigadierParser::Dimension),
+            BrigadierParserType::Uuid => Ok(BrigadierParser::Uuid),
+            BrigadierParserType::NbtTag => Ok(BrigadierParser::NbtTag),
+            BrigadierParserType::NbtCompoundTag => Ok(BrigadierParser::NbtCompoundTag),
+            BrigadierParserType::Time => Ok(BrigadierParser::Time),
+            BrigadierParserType::ResourceOrTag => Ok(BrigadierParser::ResourceOrTag {
                 registry_key: buf.read_resource_location()?,
-            })
-        } else if parser == ResourceLocation::new("minecraft:resource")? {
-            Ok(BrigadierParser::Resource {
+            }),
+            BrigadierParserType::Resource => Ok(BrigadierParser::Resource {
                 registry_key: buf.read_resource_location()?,
-            })
-        } else {
-            panic!("Unknown Brigadier parser: {}", parser)
+            }),
         }
     }
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_login_packet.rs b/azalea-protocol/src/packets/game/clientbound_login_packet.rs
index b4a1b8d4..6ddc6b5a 100755
--- a/azalea-protocol/src/packets/game/clientbound_login_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_login_packet.rs
@@ -1,4 +1,4 @@
-use azalea_core::{game_type::GameType, resource_location::ResourceLocation};
+use azalea_core::{game_type::GameType, resource_location::ResourceLocation, GlobalPos};
 use packet_macros::{GamePacket, McBuf};
 
 #[derive(Clone, Debug, McBuf, GamePacket)]
@@ -9,7 +9,7 @@ pub struct ClientboundLoginPacket {
     pub previous_game_type: Option<GameType>,
     pub levels: Vec<ResourceLocation>,
     pub registry_holder: azalea_nbt::Tag,
-    pub dimension_type: azalea_nbt::Tag,
+    pub dimension_type: ResourceLocation,
     pub dimension: ResourceLocation,
     pub seed: i64,
     #[var]
@@ -22,4 +22,5 @@ pub struct ClientboundLoginPacket {
     pub show_death_screen: bool,
     pub is_debug: bool,
     pub is_flat: bool,
+    pub last_death_location: Option<GlobalPos>,
 }
diff --git a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
index f7de4c21..58d48ffe 100755
--- a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
+++ b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
@@ -1,37 +1,11 @@
-use std::{
-    hash::Hash,
-    io::{Read, Write},
-};
+use packet_macros::LoginPacket;
+use packet_macros::McBuf;
 
-use super::LoginPacket;
-use crate::mc_buf::Readable;
-
-#[derive(Hash, Clone, Debug)]
+#[derive(Clone, Debug, McBuf, LoginPacket)]
 pub struct ClientboundHelloPacket {
+    // TODO: make this len thing work
+    // #[len(20)]
     pub server_id: String,
     pub public_key: Vec<u8>,
     pub nonce: Vec<u8>,
 }
-
-impl ClientboundHelloPacket {
-    pub fn get(self) -> LoginPacket {
-        LoginPacket::ClientboundHelloPacket(self)
-    }
-
-    pub fn write(&self, _buf: &mut impl Write) -> Result<(), std::io::Error> {
-        panic!("ClientboundHelloPacket::write not implemented")
-    }
-
-    pub fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
-        let server_id = buf.read_utf_with_len(20)?;
-        let public_key = buf.read_byte_array()?;
-        let nonce = buf.read_byte_array()?;
-
-        Ok(ClientboundHelloPacket {
-            server_id,
-            public_key,
-            nonce,
-        }
-        .get())
-    }
-}
diff --git a/azalea-protocol/src/packets/login/serverbound_key_packet.rs b/azalea-protocol/src/packets/login/serverbound_key_packet.rs
index 9100823d..2c970036 100644
--- a/azalea-protocol/src/packets/login/serverbound_key_packet.rs
+++ b/azalea-protocol/src/packets/login/serverbound_key_packet.rs
@@ -1,8 +1,49 @@
+use azalea_crypto::SaltSignaturePair;
 use packet_macros::{LoginPacket, McBuf};
-use std::hash::Hash;
+use std::{
+    hash::Hash,
+    io::{Read, Write},
+};
 
-#[derive(Hash, Clone, Debug, McBuf, LoginPacket)]
+use crate::mc_buf::{McBufReadable, McBufWritable};
+
+#[derive(Clone, Debug, McBuf, LoginPacket)]
 pub struct ServerboundKeyPacket {
-    pub shared_secret: Vec<u8>,
-    pub nonce: Vec<u8>,
+    pub key_bytes: Vec<u8>,
+    pub nonce_or_salt_signature: NonceOrSaltSignature,
+}
+
+#[derive(Clone, Debug)]
+pub enum NonceOrSaltSignature {
+    Nonce(Vec<u8>),
+    SaltSignature(SaltSignaturePair),
+}
+
+impl McBufReadable for NonceOrSaltSignature {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let is_nonce = bool::read_into(buf)?;
+        if is_nonce {
+            Ok(NonceOrSaltSignature::Nonce(Vec::<u8>::read_into(buf)?))
+        } else {
+            Ok(NonceOrSaltSignature::SaltSignature(
+                SaltSignaturePair::read_into(buf)?,
+            ))
+        }
+    }
+}
+
+impl McBufWritable for NonceOrSaltSignature {
+    fn write_into(&self, buf: &mut impl Write) -> Result<(), std::io::Error> {
+        match self {
+            NonceOrSaltSignature::Nonce(nonce) => {
+                bool::write_into(&true, buf)?;
+                nonce.write_into(buf)?;
+            }
+            NonceOrSaltSignature::SaltSignature(salt_signature) => {
+                bool::write_into(&false, buf)?;
+                salt_signature.write_into(buf)?;
+            }
+        }
+        Ok(())
+    }
 }
diff --git a/login.txt b/login.txt
new file mode 100644
index 00000000..22a2dc6c
--- /dev/null
+++ b/login.txt
@@ -0,0 +1,4812 @@
+ClientboundLoginPacket {
+    player_id: 30321,
+    hardcore: false,
+    game_type: CREATIVE,
+    previous_game_type: None,
+    levels: [
+        minecraft:overworld,
+        minecraft:the_nether,
+        minecraft:the_end,
+    ],
+    registry_holder: Compound(
+        {
+            "": Compound(
+                {
+                    "minecraft:chat_type": Compound(
+                        {
+                            "type": String(
+                                "minecraft:chat_type",
+                            ),
+                            "value": List(
+                                [
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                0,
+                                            ),
+                                            "name": String(
+                                                "minecraft:chat",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "chat": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "chat.type.text",
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "narration": Compound(
+                                                        {
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "translation_key": String(
+                                                                        "chat.type.text.narrate",
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:system",
+                                            ),
+                                            "id": Int(
+                                                1,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "chat": Compound(
+                                                        {},
+                                                    ),
+                                                    "narration": Compound(
+                                                        {
+                                                            "priority": String(
+                                                                "system",
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:game_info",
+                                            ),
+                                            "id": Int(
+                                                2,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "overlay": Compound(
+                                                        {},
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                3,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "chat": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "translation_key": String(
+                                                                        "chat.type.announcement",
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "narration": Compound(
+                                                        {
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "translation_key": String(
+                                                                        "chat.type.text.narrate",
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:say_command",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                4,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "chat": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "commands.message.display.incoming",
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {
+                                                                            "italic": Byte(
+                                                                                1,
+                                                                            ),
+                                                                            "color": String(
+                                                                                "gray",
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "narration": Compound(
+                                                        {
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "chat.type.text.narrate",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:msg_command",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                5,
+                                            ),
+                                            "name": String(
+                                                "minecraft:team_msg_command",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "narration": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "chat.type.text.narrate",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "chat": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "team_name",
+                                                                            ),
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "chat.type.team.text",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:emote_command",
+                                            ),
+                                            "id": Int(
+                                                6,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "narration": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                    "translation_key": String(
+                                                                        "chat.type.emote",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "chat": Compound(
+                                                        {
+                                                            "decoration": Compound(
+                                                                {
+                                                                    "translation_key": String(
+                                                                        "chat.type.emote",
+                                                                    ),
+                                                                    "parameters": List(
+                                                                        [
+                                                                            String(
+                                                                                "sender",
+                                                                            ),
+                                                                            String(
+                                                                                "content",
+                                                                            ),
+                                                                        ],
+                                                                    ),
+                                                                    "style": Compound(
+                                                                        {},
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "narration": Compound(
+                                                        {
+                                                            "priority": String(
+                                                                "chat",
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "chat": Compound(
+                                                        {},
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:tellraw_command",
+                                            ),
+                                            "id": Int(
+                                                7,
+                                            ),
+                                        },
+                                    ),
+                                ],
+                            ),
+                        },
+                    ),
+                    "minecraft:worldgen/biome": Compound(
+                        {
+                            "type": String(
+                                "minecraft:worldgen/biome",
+                            ),
+                            "value": List(
+                                [
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                0,
+                                            ),
+                                            "name": String(
+                                                "minecraft:the_void",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:plains",
+                                            ),
+                                            "id": Int(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                2,
+                                            ),
+                                            "name": String(
+                                                "minecraft:sunflower_plains",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:snowy_plains",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8364543,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                3,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                4,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8364543,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.0,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:ice_spikes",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:desert",
+                                            ),
+                                            "id": Int(
+                                                5,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                2302743,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.swamp",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                6388580,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "foliage_color": Int(
+                                                                6975545,
+                                                            ),
+                                                            "grass_color_modifier": String(
+                                                                "swamp",
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:swamp",
+                                            ),
+                                            "id": Int(
+                                                6,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                7,
+                                            ),
+                                            "name": String(
+                                                "minecraft:mangrove_swamp",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "foliage_color": Int(
+                                                                9285927,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.swamp",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "grass_color_modifier": String(
+                                                                "swamp",
+                                                            ),
+                                                            "water_color": Int(
+                                                                3832426,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                5077600,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                8,
+                                            ),
+                                            "name": String(
+                                                "minecraft:forest",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.7,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7972607,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.7,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7972607,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:flower_forest",
+                                            ),
+                                            "id": Int(
+                                                9,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:birch_forest",
+                                            ),
+                                            "id": Int(
+                                                10,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.6,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.6,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8037887,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:dark_forest",
+                                            ),
+                                            "id": Int(
+                                                11,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.7,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                7972607,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "grass_color_modifier": String(
+                                                                "dark_forest",
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.6,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                8037887,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.6,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:old_growth_birch_forest",
+                                            ),
+                                            "id": Int(
+                                                12,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.old_growth_taiga",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8168447,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.3,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                13,
+                                            ),
+                                            "name": String(
+                                                "minecraft:old_growth_pine_taiga",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:old_growth_spruce_taiga",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.25,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8233983,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.old_growth_taiga",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                14,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:taiga",
+                                            ),
+                                            "id": Int(
+                                                15,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8233983,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.25,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "temperature": Float(
+                                                        -0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4020182,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8625919,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:snowy_taiga",
+                                            ),
+                                            "id": Int(
+                                                16,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:savanna",
+                                            ),
+                                            "id": Int(
+                                                17,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:savanna_plateau",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                18,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8233727,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.2,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                19,
+                                            ),
+                                            "name": String(
+                                                "minecraft:windswept_hills",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                20,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8233727,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.2,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:windswept_gravelly_hills",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.2,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8233727,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:windswept_forest",
+                                            ),
+                                            "id": Int(
+                                                21,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                22,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:windswept_savanna",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.95,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7842047,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:jungle",
+                                            ),
+                                            "id": Int(
+                                                23,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                24,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.95,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7842047,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:sparse_jungle",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:bamboo_jungle",
+                                            ),
+                                            "id": Int(
+                                                25,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.95,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jungle_and_forest",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7842047,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                26,
+                                            ),
+                                            "name": String(
+                                                "minecraft:badlands",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "foliage_color": Int(
+                                                                10387789,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "grass_color": Int(
+                                                                9470285,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "foliage_color": Int(
+                                                                10387789,
+                                                            ),
+                                                            "grass_color": Int(
+                                                                9470285,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                27,
+                                            ),
+                                            "name": String(
+                                                "minecraft:eroded_badlands",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                28,
+                                            ),
+                                            "name": String(
+                                                "minecraft:wooded_badlands",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "foliage_color": Int(
+                                                                10387789,
+                                                            ),
+                                                            "grass_color": Int(
+                                                                9470285,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.meadow",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                937679,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:meadow",
+                                            ),
+                                            "id": Int(
+                                                29,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:grove",
+                                            ),
+                                            "id": Int(
+                                                30,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.8,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.grove",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8495359,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        -0.2,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        -0.3,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.snowy_slopes",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8560639,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                31,
+                                            ),
+                                            "name": String(
+                                                "minecraft:snowy_slopes",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                32,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.frozen_peaks",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8756735,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "temperature": Float(
+                                                        -0.7,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:frozen_peaks",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                33,
+                                            ),
+                                            "name": String(
+                                                "minecraft:jagged_peaks",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.jagged_peaks",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8756735,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        -0.7,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.9,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:stony_peaks",
+                                            ),
+                                            "id": Int(
+                                                34,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.stony_peaks",
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7776511,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        1.0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                35,
+                                            ),
+                                            "name": String(
+                                                "minecraft:river",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8364543,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                3750089,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:frozen_river",
+                                            ),
+                                            "id": Int(
+                                                36,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:beach",
+                                            ),
+                                            "id": Int(
+                                                37,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:snowy_beach",
+                                            ),
+                                            "id": Int(
+                                                38,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.05,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                8364543,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4020182,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.2,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.3,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                8233727,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:stony_shore",
+                                            ),
+                                            "id": Int(
+                                                39,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:warm_ocean",
+                                            ),
+                                            "id": Int(
+                                                40,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                270131,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4445678,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                267827,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4566514,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:lukewarm_ocean",
+                                            ),
+                                            "id": Int(
+                                                41,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:deep_lukewarm_ocean",
+                                            ),
+                                            "id": Int(
+                                                42,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4566514,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                267827,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                43,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:ocean",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:deep_ocean",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                44,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:cold_ocean",
+                                            ),
+                                            "id": Int(
+                                                45,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4020182,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                46,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4020182,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:deep_cold_ocean",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                47,
+                                            ),
+                                            "name": String(
+                                                "minecraft:frozen_ocean",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature_modifier": String(
+                                                        "frozen",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "snow",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                8364543,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                3750089,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                48,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "temperature_modifier": String(
+                                                        "frozen",
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                3750089,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:deep_frozen_ocean",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        1.0,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.9,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7842047,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                49,
+                                            ),
+                                            "name": String(
+                                                "minecraft:mushroom_fields",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.dripstone_caves",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:dripstone_caves",
+                                            ),
+                                            "id": Int(
+                                                50,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                51,
+                                            ),
+                                            "name": String(
+                                                "minecraft:lush_caves",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.lush_caves",
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                8103167,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "precipitation": String(
+                                                        "rain",
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.8,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                12638463,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.overworld.deep_dark",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7907327,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.4,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                52,
+                                            ),
+                                            "name": String(
+                                                "minecraft:deep_dark",
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                53,
+                                            ),
+                                            "name": String(
+                                                "minecraft:nether_wastes",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "music": Compound(
+                                                                {
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.nether.nether_wastes",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "additions_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.nether_wastes.additions",
+                                                                    ),
+                                                                    "tick_chance": Double(
+                                                                        0.0111,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.nether_wastes.mood",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "ambient_sound": String(
+                                                                "minecraft:ambient.nether_wastes.loop",
+                                                            ),
+                                                            "fog_color": Int(
+                                                                3344392,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:warped_forest",
+                                            ),
+                                            "id": Int(
+                                                54,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "ambient_sound": String(
+                                                                "minecraft:ambient.warped_forest.loop",
+                                                            ),
+                                                            "particle": Compound(
+                                                                {
+                                                                    "probability": Float(
+                                                                        0.01428,
+                                                                    ),
+                                                                    "options": Compound(
+                                                                        {
+                                                                            "type": String(
+                                                                                "minecraft:warped_spore",
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "additions_sound": Compound(
+                                                                {
+                                                                    "tick_chance": Double(
+                                                                        0.0111,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.warped_forest.additions",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                1705242,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.nether.warped_forest",
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.warped_forest.mood",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                55,
+                                            ),
+                                            "name": String(
+                                                "minecraft:crimson_forest",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "effects": Compound(
+                                                        {
+                                                            "ambient_sound": String(
+                                                                "minecraft:ambient.crimson_forest.loop",
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                3343107,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.crimson_forest.mood",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.nether.crimson_forest",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "additions_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.crimson_forest.additions",
+                                                                    ),
+                                                                    "tick_chance": Double(
+                                                                        0.0111,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "particle": Compound(
+                                                                {
+                                                                    "probability": Float(
+                                                                        0.025,
+                                                                    ),
+                                                                    "options": Compound(
+                                                                        {
+                                                                            "type": String(
+                                                                                "minecraft:crimson_spore",
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:soul_sand_valley",
+                                            ),
+                                            "id": Int(
+                                                56,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.nether.soul_sand_valley",
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "ambient_sound": String(
+                                                                "minecraft:ambient.soul_sand_valley.loop",
+                                                            ),
+                                                            "particle": Compound(
+                                                                {
+                                                                    "options": Compound(
+                                                                        {
+                                                                            "type": String(
+                                                                                "minecraft:ash",
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                    "probability": Float(
+                                                                        0.00625,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.soul_sand_valley.mood",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "additions_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.soul_sand_valley.additions",
+                                                                    ),
+                                                                    "tick_chance": Double(
+                                                                        0.0111,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                1787717,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:basalt_deltas",
+                                            ),
+                                            "id": Int(
+                                                57,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.0,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                6840176,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                7254527,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.basalt_deltas.mood",
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "music": Compound(
+                                                                {
+                                                                    "min_delay": Int(
+                                                                        12000,
+                                                                    ),
+                                                                    "max_delay": Int(
+                                                                        24000,
+                                                                    ),
+                                                                    "replace_current_music": Byte(
+                                                                        0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:music.nether.basalt_deltas",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "ambient_sound": String(
+                                                                "minecraft:ambient.basalt_deltas.loop",
+                                                            ),
+                                                            "additions_sound": Compound(
+                                                                {
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.basalt_deltas.additions",
+                                                                    ),
+                                                                    "tick_chance": Double(
+                                                                        0.0111,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "particle": Compound(
+                                                                {
+                                                                    "probability": Float(
+                                                                        0.118093334,
+                                                                    ),
+                                                                    "options": Compound(
+                                                                        {
+                                                                            "type": String(
+                                                                                "minecraft:white_ash",
+                                                                            ),
+                                                                        },
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "temperature": Float(
+                                                        2.0,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:the_end",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "fog_color": Int(
+                                                                10518688,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                0,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                58,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:end_highlands",
+                                            ),
+                                            "id": Int(
+                                                59,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                10518688,
+                                                            ),
+                                                            "sky_color": Int(
+                                                                0,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                0,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                10518688,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:end_midlands",
+                                            ),
+                                            "id": Int(
+                                                60,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                61,
+                                            ),
+                                            "name": String(
+                                                "minecraft:small_end_islands",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "sky_color": Int(
+                                                                0,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "fog_color": Int(
+                                                                10518688,
+                                                            ),
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                62,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "temperature": Float(
+                                                        0.5,
+                                                    ),
+                                                    "downfall": Float(
+                                                        0.5,
+                                                    ),
+                                                    "precipitation": String(
+                                                        "none",
+                                                    ),
+                                                    "effects": Compound(
+                                                        {
+                                                            "water_fog_color": Int(
+                                                                329011,
+                                                            ),
+                                                            "water_color": Int(
+                                                                4159204,
+                                                            ),
+                                                            "fog_color": Int(
+                                                                10518688,
+                                                            ),
+                                                            "mood_sound": Compound(
+                                                                {
+                                                                    "tick_delay": Int(
+                                                                        6000,
+                                                                    ),
+                                                                    "offset": Double(
+                                                                        2.0,
+                                                                    ),
+                                                                    "sound": String(
+                                                                        "minecraft:ambient.cave",
+                                                                    ),
+                                                                    "block_search_extent": Int(
+                                                                        8,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "sky_color": Int(
+                                                                0,
+                                                            ),
+                                                        },
+                                                    ),
+                                                },
+                                            ),
+                                            "name": String(
+                                                "minecraft:end_barrens",
+                                            ),
+                                        },
+                                    ),
+                                ],
+                            ),
+                        },
+                    ),
+                    "minecraft:dimension_type": Compound(
+                        {
+                            "type": String(
+                                "minecraft:dimension_type",
+                            ),
+                            "value": List(
+                                [
+                                    Compound(
+                                        {
+                                            "id": Int(
+                                                0,
+                                            ),
+                                            "name": String(
+                                                "minecraft:overworld",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "infiniburn": String(
+                                                        "#minecraft:infiniburn_overworld",
+                                                    ),
+                                                    "respawn_anchor_works": Byte(
+                                                        0,
+                                                    ),
+                                                    "bed_works": Byte(
+                                                        1,
+                                                    ),
+                                                    "has_skylight": Byte(
+                                                        1,
+                                                    ),
+                                                    "natural": Byte(
+                                                        1,
+                                                    ),
+                                                    "effects": String(
+                                                        "minecraft:overworld",
+                                                    ),
+                                                    "height": Int(
+                                                        384,
+                                                    ),
+                                                    "monster_spawn_light_level": Compound(
+                                                        {
+                                                            "type": String(
+                                                                "minecraft:uniform",
+                                                            ),
+                                                            "value": Compound(
+                                                                {
+                                                                    "min_inclusive": Int(
+                                                                        0,
+                                                                    ),
+                                                                    "max_inclusive": Int(
+                                                                        7,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "has_raids": Byte(
+                                                        1,
+                                                    ),
+                                                    "ultrawarm": Byte(
+                                                        0,
+                                                    ),
+                                                    "min_y": Int(
+                                                        -64,
+                                                    ),
+                                                    "monster_spawn_block_light_limit": Int(
+                                                        0,
+                                                    ),
+                                                    "logical_height": Int(
+                                                        384,
+                                                    ),
+                                                    "ambient_light": Float(
+                                                        0.0,
+                                                    ),
+                                                    "coordinate_scale": Double(
+                                                        1.0,
+                                                    ),
+                                                    "piglin_safe": Byte(
+                                                        0,
+                                                    ),
+                                                    "has_ceiling": Byte(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:the_nether",
+                                            ),
+                                            "id": Int(
+                                                1,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "has_raids": Byte(
+                                                        0,
+                                                    ),
+                                                    "coordinate_scale": Double(
+                                                        8.0,
+                                                    ),
+                                                    "piglin_safe": Byte(
+                                                        1,
+                                                    ),
+                                                    "monster_spawn_block_light_limit": Int(
+                                                        15,
+                                                    ),
+                                                    "monster_spawn_light_level": Int(
+                                                        11,
+                                                    ),
+                                                    "respawn_anchor_works": Byte(
+                                                        1,
+                                                    ),
+                                                    "effects": String(
+                                                        "minecraft:the_nether",
+                                                    ),
+                                                    "fixed_time": Long(
+                                                        18000,
+                                                    ),
+                                                    "infiniburn": String(
+                                                        "#minecraft:infiniburn_nether",
+                                                    ),
+                                                    "has_skylight": Byte(
+                                                        0,
+                                                    ),
+                                                    "logical_height": Int(
+                                                        128,
+                                                    ),
+                                                    "has_ceiling": Byte(
+                                                        1,
+                                                    ),
+                                                    "ambient_light": Float(
+                                                        0.1,
+                                                    ),
+                                                    "bed_works": Byte(
+                                                        0,
+                                                    ),
+                                                    "height": Int(
+                                                        256,
+                                                    ),
+                                                    "natural": Byte(
+                                                        0,
+                                                    ),
+                                                    "min_y": Int(
+                                                        0,
+                                                    ),
+                                                    "ultrawarm": Byte(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:the_end",
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "has_ceiling": Byte(
+                                                        0,
+                                                    ),
+                                                    "fixed_time": Long(
+                                                        6000,
+                                                    ),
+                                                    "effects": String(
+                                                        "minecraft:the_end",
+                                                    ),
+                                                    "coordinate_scale": Double(
+                                                        1.0,
+                                                    ),
+                                                    "height": Int(
+                                                        256,
+                                                    ),
+                                                    "infiniburn": String(
+                                                        "#minecraft:infiniburn_end",
+                                                    ),
+                                                    "ambient_light": Float(
+                                                        0.0,
+                                                    ),
+                                                    "has_skylight": Byte(
+                                                        0,
+                                                    ),
+                                                    "has_raids": Byte(
+                                                        1,
+                                                    ),
+                                                    "monster_spawn_block_light_limit": Int(
+                                                        0,
+                                                    ),
+                                                    "monster_spawn_light_level": Compound(
+                                                        {
+                                                            "value": Compound(
+                                                                {
+                                                                    "min_inclusive": Int(
+                                                                        0,
+                                                                    ),
+                                                                    "max_inclusive": Int(
+                                                                        7,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                            "type": String(
+                                                                "minecraft:uniform",
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "piglin_safe": Byte(
+                                                        0,
+                                                    ),
+                                                    "natural": Byte(
+                                                        0,
+                                                    ),
+                                                    "respawn_anchor_works": Byte(
+                                                        0,
+                                                    ),
+                                                    "logical_height": Int(
+                                                        256,
+                                                    ),
+                                                    "ultrawarm": Byte(
+                                                        0,
+                                                    ),
+                                                    "min_y": Int(
+                                                        0,
+                                                    ),
+                                                    "bed_works": Byte(
+                                                        0,
+                                                    ),
+                                                },
+                                            ),
+                                            "id": Int(
+                                                2,
+                                            ),
+                                        },
+                                    ),
+                                    Compound(
+                                        {
+                                            "name": String(
+                                                "minecraft:overworld_caves",
+                                            ),
+                                            "id": Int(
+                                                3,
+                                            ),
+                                            "element": Compound(
+                                                {
+                                                    "monster_spawn_block_light_limit": Int(
+                                                        0,
+                                                    ),
+                                                    "height": Int(
+                                                        384,
+                                                    ),
+                                                    "logical_height": Int(
+                                                        384,
+                                                    ),
+                                                    "min_y": Int(
+                                                        -64,
+                                                    ),
+                                                    "has_ceiling": Byte(
+                                                        1,
+                                                    ),
+                                                    "effects": String(
+                                                        "minecraft:overworld",
+                                                    ),
+                                                    "has_raids": Byte(
+                                                        1,
+                                                    ),
+                                                    "ambient_light": Float(
+                                                        0.0,
+                                                    ),
+                                                    "piglin_safe": Byte(
+                                                        0,
+                                                    ),
+                                                    "infiniburn": String(
+                                                        "#minecraft:infiniburn_overworld",
+                                                    ),
+                                                    "respawn_anchor_works": Byte(
+                                                        0,
+                                                    ),
+                                                    "natural": Byte(
+                                                        1,
+                                                    ),
+                                                    "ultrawarm": Byte(
+                                                        0,
+                                                    ),
+                                                    "monster_spawn_light_level": Compound(
+                                                        {
+                                                            "type": String(
+                                                                "minecraft:uniform",
+                                                            ),
+                                                            "value": Compound(
+                                                                {
+                                                                    "min_inclusive": Int(
+                                                                        0,
+                                                                    ),
+                                                                    "max_inclusive": Int(
+                                                                        7,
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        },
+                                                    ),
+                                                    "has_skylight": Byte(
+                                                        1,
+                                                    ),
+                                                    "coordinate_scale": Double(
+                                                        1.0,
+                                                    ),
+                                                    "bed_works": Byte(
+                                                        1,
+                                                    ),
+                                                },
+                                            ),
+                                        },
+                                    ),
+                                ],
+                            ),
+                        },
+                    ),
+                },
+            ),
+        },
+    ),
+    dimension_type: minecraft:overworld,
+    dimension: minecraft:overworld,
+    seed: 3162381063931772330,
+    max_players: 8,
+    chunk_radius: 12,
+    simulation_distance: 8,
+    reduced_debug_info: false,
+    show_death_screen: true,
+    is_debug: false,
+    is_flat: false,
+    last_death_location: None,
+}
\ No newline at end of file