package com.dairymoose.modernlife.core;

import com.dairymoose.entity.BicycleEntity;
import com.dairymoose.entity.DummyEntity;
import com.dairymoose.entity.MotorboatEntity;
import com.dairymoose.entity.projectile.ThrownSeedEntity;
import com.dairymoose.inventory.container.TrashCanContainer;
import com.dairymoose.modernlife.blocks.AirConditionerBlock;
import com.dairymoose.modernlife.blocks.AlarmClockBlock;
import com.dairymoose.modernlife.blocks.AlmostFullBlock;
import com.dairymoose.modernlife.blocks.ArrowSlitBlock;
import com.dairymoose.modernlife.blocks.BarrierBlock;
import com.dairymoose.modernlife.blocks.BathtubBlock;
import com.dairymoose.modernlife.blocks.CCTVCameraBlock;
import com.dairymoose.modernlife.blocks.CanvasBlock;
import com.dairymoose.modernlife.blocks.CatwalkBlock;
import com.dairymoose.modernlife.blocks.CeilingFanBlock;
import com.dairymoose.modernlife.blocks.ChairBlock;
import com.dairymoose.modernlife.blocks.ChessBoardBlock;
import com.dairymoose.modernlife.blocks.CoffeeMugBlock;
import com.dairymoose.modernlife.blocks.CoffeeTableBlock;
import com.dairymoose.modernlife.blocks.DeckBlock;
import com.dairymoose.modernlife.blocks.DeluxeBedBlock;
import com.dairymoose.modernlife.blocks.DoubleWallShelfBlock;
import com.dairymoose.modernlife.blocks.DualMonitorBlock;
import com.dairymoose.modernlife.blocks.EaselBlock;
import com.dairymoose.modernlife.blocks.ExtractorBlock;
import com.dairymoose.modernlife.blocks.FlatScreenTvBlock;
import com.dairymoose.modernlife.blocks.FloorMatBlock;
import com.dairymoose.modernlife.blocks.GlassCoffeeTableBlock;
import com.dairymoose.modernlife.blocks.GlassPanelBlock;
import com.dairymoose.modernlife.blocks.GrateBlock;
import com.dairymoose.modernlife.blocks.GuitarAmplifierBlock;
import com.dairymoose.modernlife.blocks.HotWaterHeaterBlock;
import com.dairymoose.modernlife.blocks.JailBarsBlock;
import com.dairymoose.modernlife.blocks.KitchenCabinetBlock;
import com.dairymoose.modernlife.blocks.KitchenDrawerCabinetBlock;
import com.dairymoose.modernlife.blocks.KitchenSinkBlock;
import com.dairymoose.modernlife.blocks.LanternPostBlock;
import com.dairymoose.modernlife.blocks.LightBulbBlock;
import com.dairymoose.modernlife.blocks.LightSwitchBlock;
import com.dairymoose.modernlife.blocks.MetalDuctBlock;
import com.dairymoose.modernlife.blocks.MicrowaveBlock;
import com.dairymoose.modernlife.blocks.MiniStoolBlock;
import com.dairymoose.modernlife.blocks.MirrorBlock;
import com.dairymoose.modernlife.blocks.ModernBookshelfBlock;
import com.dairymoose.modernlife.blocks.MonitorBlock;
import com.dairymoose.modernlife.blocks.MusicStandBlock;
import com.dairymoose.modernlife.blocks.NightStandBlock;
import com.dairymoose.modernlife.blocks.PavedRoadBlock;
import com.dairymoose.modernlife.blocks.PhotocopierBlock;
import com.dairymoose.modernlife.blocks.PhotonBlock;
import com.dairymoose.modernlife.blocks.PicnicTableBlock;
import com.dairymoose.modernlife.blocks.PowerReceiverBlock;
import com.dairymoose.modernlife.blocks.PowerTransmitterBlock;
import com.dairymoose.modernlife.blocks.PrinterBlock;
import com.dairymoose.modernlife.blocks.RadiatorBlock;
import com.dairymoose.modernlife.blocks.RampBlock;
import com.dairymoose.modernlife.blocks.RefrigeratorBlock;
import com.dairymoose.modernlife.blocks.RoadMarkerBlock;
import com.dairymoose.modernlife.blocks.RoundTableBlock;
import com.dairymoose.modernlife.blocks.SeedSpreaderBlock;
import com.dairymoose.modernlife.blocks.ShowerHeadBlock;
import com.dairymoose.modernlife.blocks.SmallTableBlock;
import com.dairymoose.modernlife.blocks.SofaBlock;
import com.dairymoose.modernlife.blocks.StoveBlock;
import com.dairymoose.modernlife.blocks.StreetLightBlock;
import com.dairymoose.modernlife.blocks.TileLightBlock;
import com.dairymoose.modernlife.blocks.ToiletBlock;
import com.dairymoose.modernlife.blocks.TrashCanBlock;
import com.dairymoose.modernlife.blocks.TurntableBlock;
import com.dairymoose.modernlife.blocks.WallShelfBlock;
import com.dairymoose.modernlife.blocks.WallSocketBlock;
import com.dairymoose.modernlife.blocks.WinchBlock;
import com.dairymoose.modernlife.items.BatteryItem;
import com.dairymoose.modernlife.items.BicycleItem;
import com.dairymoose.modernlife.items.CameraItem;
import com.dairymoose.modernlife.items.ChainsawItem;
import com.dairymoose.modernlife.items.FlashlightItem;
import com.dairymoose.modernlife.items.GuitarItem;
import com.dairymoose.modernlife.items.HandgunItem;
import com.dairymoose.modernlife.items.MotorboatItem;
import com.dairymoose.modernlife.items.RoadMarkerItem;
import com.dairymoose.modernlife.items.SpeedometerItem;
import com.dairymoose.modernlife.renderer.tileentity.CanvasBlockEntityRenderer;
import com.dairymoose.modernlife.tileentities.AlarmClockBlockEntity;
import com.dairymoose.modernlife.tileentities.CCTVCameraBlockEntity;
import com.dairymoose.modernlife.tileentities.CanvasBlockEntity;
import com.dairymoose.modernlife.tileentities.ChessBoardBlockEntity;
import com.dairymoose.modernlife.tileentities.EaselBlockEntity;
import com.dairymoose.modernlife.tileentities.ExtractorBlockEntity;
import com.dairymoose.modernlife.tileentities.MicrowaveBlockEntity;
import com.dairymoose.modernlife.tileentities.MirrorBlockEntity;
import com.dairymoose.modernlife.tileentities.ModernBookshelfBlockEntity;
import com.dairymoose.modernlife.tileentities.NightStandBlockEntity;
import com.dairymoose.modernlife.tileentities.PhotocopierBlockEntity;
import com.dairymoose.modernlife.tileentities.PhotonBlockEntity;
import com.dairymoose.modernlife.tileentities.PowerReceiverBlockEntity;
import com.dairymoose.modernlife.tileentities.PowerTransmitterBlockEntity;
import com.dairymoose.modernlife.tileentities.PrinterBlockEntity;
import com.dairymoose.modernlife.tileentities.RadiatorBlockEntity;
import com.dairymoose.modernlife.tileentities.RefrigeratorBlockEntity;
import com.dairymoose.modernlife.tileentities.SeedSpreaderBlockEntity;
import com.dairymoose.modernlife.tileentities.ShowerHeadBlockEntity;
import com.dairymoose.modernlife.tileentities.StoveBlockEntity;
import com.dairymoose.modernlife.tileentities.ToiletBlockEntity;
import com.dairymoose.modernlife.tileentities.TrashCanBlockEntity;
import com.dairymoose.modernlife.tileentities.WallShelfBlockEntity;
import com.dairymoose.modernlife.tileentities.WinchBlockEntity;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.inventory.MenuType;
import net.minecraft.world.item.BlockItem;
import net.minecraft.world.item.CreativeModeTab;
import net.minecraft.world.item.DoubleHighBlockItem;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.Tier;
import net.minecraft.world.item.crafting.Ingredient;
import net.minecraft.world.level.ItemLike;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.DoorBlock;
import net.minecraft.world.level.block.SlabBlock;
import net.minecraft.world.level.block.SoundType;
import net.minecraft.world.level.block.StairBlock;
import net.minecraft.world.level.block.TrapDoorBlock;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockBehaviour;
import net.minecraft.world.level.material.Material;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.registries.RegistryObject;

/* loaded from: outputsrg.jar:com/dairymoose/modernlife/core/CustomBlocks.class */
public class CustomBlocks {

    @OnlyIn(Dist.CLIENT)
    public static CanvasBlockEntityRenderer RENDERER_CANVAS;

    @AutoRegister(name = "steam_radiator")
    public static RegistryObject<Block> BLOCK_RADIATOR = ModernLifeCommon.BLOCKS.register("steam_radiator", () -> {
        return new RadiatorBlock();
    });

    @AutoRegister(name = "steam_radiator")
    public static RegistryObject<Item> ITEM_RADIATOR = ModernLifeCommon.ITEMS.register("steam_radiator", () -> {
        return new BlockItem(BLOCK_RADIATOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC).fireResistant().stacksTo(64));
    });

    @AutoRegister(name = "easel")
    public static RegistryObject<Block> BLOCK_EASEL = ModernLifeCommon.BLOCKS.register("easel", () -> {
        return new EaselBlock();
    });

    @AutoRegister(name = "easel")
    public static RegistryObject<Item> ITEM_EASEL = ModernLifeCommon.ITEMS.register("easel", () -> {
        return new BlockItem(BLOCK_EASEL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS).stacksTo(64));
    });

    @AutoRegister(name = "light_switch")
    public static RegistryObject<Block> BLOCK_LIGHTSWITCH = ModernLifeCommon.BLOCKS.register("light_switch", () -> {
        return new LightSwitchBlock();
    });

    @AutoRegister(name = "light_switch")
    public static RegistryObject<Item> ITEM_LIGHTSWITCH = ModernLifeCommon.ITEMS.register("light_switch", () -> {
        return new BlockItem(BLOCK_LIGHTSWITCH.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE).stacksTo(64));
    });

    @AutoRegister(name = "canvas")
    public static RegistryObject<Block> BLOCK_CANVAS = ModernLifeCommon.BLOCKS.register("canvas", () -> {
        return new CanvasBlock();
    });

    @AutoRegister(name = "canvas")
    public static RegistryObject<Item> ITEM_CANVAS = ModernLifeCommon.ITEMS.register("canvas", () -> {
        return new BlockItem(BLOCK_CANVAS.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS).stacksTo(1));
    });

    @AutoRegister(name = "faceless_canvas", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_FACELESS_CANVAS = ModernLifeCommon.BLOCKS.register("faceless_canvas", () -> {
        return new CanvasBlock();
    });

    @AutoRegister(name = "cctv_camera", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_CCTV_CAMERA = ModernLifeCommon.BLOCKS.register("cctv_camera", () -> {
        return new CCTVCameraBlock(BlockBehaviour.Properties.copy(Blocks.HOPPER));
    });

    @AutoRegister(name = "cctv_camera")
    public static RegistryObject<Item> ITEM_CCTV_CAMERA = ModernLifeCommon.ITEMS.register("cctv_camera", () -> {
        return new BlockItem(BLOCK_CCTV_CAMERA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cctv_screen", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_CCTV_SCREEN = ModernLifeCommon.BLOCKS.register("cctv_screen", () -> {
        return new MirrorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "cctv_screen")
    public static RegistryObject<Item> ITEM_CCTV_SCREEN = ModernLifeCommon.ITEMS.register("cctv_screen", () -> {
        return new BlockItem(BLOCK_CCTV_SCREEN.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_oak_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_OAK_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_oak_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "modern_oak_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_OAK_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_oak_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_OAK_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_acacia_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_ACACIA_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_acacia_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "modern_acacia_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_ACACIA_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_acacia_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_ACACIA_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_birch_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_BIRCH_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_birch_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "modern_birch_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_BIRCH_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_birch_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_BIRCH_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_crimson_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_CRIMSON_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_crimson_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "modern_crimson_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_CRIMSON_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_crimson_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_CRIMSON_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_dark_oak_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_DARK_OAK_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_dark_oak_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "modern_dark_oak_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_DARK_OAK_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_dark_oak_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_DARK_OAK_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_jungle_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_JUNGLE_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_jungle_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "modern_jungle_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_JUNGLE_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_jungle_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_JUNGLE_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_spruce_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_SPRUCE_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_spruce_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "modern_spruce_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_SPRUCE_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_spruce_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_SPRUCE_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_warped_bookshelf", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_WARPED_BOOKSHELF = ModernLifeCommon.BLOCKS.register("modern_warped_bookshelf", () -> {
        return new ModernBookshelfBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "modern_warped_bookshelf")
    public static RegistryObject<Item> ITEM_MODERN_WARPED_BOOKSHELF = ModernLifeCommon.ITEMS.register("modern_warped_bookshelf", () -> {
        return new BlockItem(BLOCK_MODERN_WARPED_BOOKSHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "modern_book", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MODERN_BOOK = ModernLifeCommon.BLOCKS.register("modern_book", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "modern_book", renderType = "cutout")
    public static RegistryObject<Item> ITEM_MODERN_BOOK = ModernLifeCommon.ITEMS.register("modern_book", () -> {
        return new BlockItem(BLOCK_MODERN_BOOK.get(), new Item.Properties());
    });

    @AutoRegister(name = "mirror", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MIRROR = ModernLifeCommon.BLOCKS.register("mirror", () -> {
        return new MirrorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "mirror")
    public static RegistryObject<Item> ITEM_MIRROR = ModernLifeCommon.ITEMS.register("mirror", () -> {
        return new BlockItem(BLOCK_MIRROR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "tall_mirror", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_TALL_MIRROR = ModernLifeCommon.BLOCKS.register("tall_mirror", () -> {
        return new MirrorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "tall_mirror")
    public static RegistryObject<Item> ITEM_TALL_MIRROR = ModernLifeCommon.ITEMS.register("tall_mirror", () -> {
        return new BlockItem(BLOCK_TALL_MIRROR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "large_mirror", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_LARGE_MIRROR = ModernLifeCommon.BLOCKS.register("large_mirror", () -> {
        return new MirrorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "large_mirror")
    public static RegistryObject<Item> ITEM_LARGE_MIRROR = ModernLifeCommon.ITEMS.register("large_mirror", () -> {
        return new BlockItem(BLOCK_LARGE_MIRROR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "massive_mirror", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_MASSIVE_MIRROR = ModernLifeCommon.BLOCKS.register("massive_mirror", () -> {
        return new MirrorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "massive_mirror")
    public static RegistryObject<Item> ITEM_MASSIVE_MIRROR = ModernLifeCommon.ITEMS.register("massive_mirror", () -> {
        return new BlockItem(BLOCK_MASSIVE_MIRROR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_stairs", inheritFrom = "GLASS", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_STAIRS = ModernLifeCommon.BLOCKS.register("glass_stairs", () -> {
        return new StairBlock(Blocks.GLASS.defaultBlockState(), BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_stairs", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_GLASS_STAIRS = ModernLifeCommon.ITEMS.register("glass_stairs", () -> {
        return new BlockItem(BLOCK_GLASS_STAIRS.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "metal_catwalk", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_METAL_CATWALK = ModernLifeCommon.BLOCKS.register("metal_catwalk", () -> {
        return new CatwalkBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "metal_catwalk")
    public static RegistryObject<Item> ITEM_METAL_CATWALK = ModernLifeCommon.ITEMS.register("metal_catwalk", () -> {
        return new BlockItem(BLOCK_METAL_CATWALK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "acacia_glass_door", blockClass = DoorBlock.class, inheritFrom = "ACACIA_DOOR", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_ACACIA_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("acacia_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_DOOR));
    });

    @AutoRegister(name = "acacia_glass_door", itemClass = DoubleHighBlockItem.class, tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_ACACIA_GLASS_DOOR = ModernLifeCommon.ITEMS.register("acacia_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_ACACIA_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "modern_white_door", blockClass = DoorBlock.class, inheritFrom = "OAK_DOOR", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_MODERN_WHITE_DOOR = ModernLifeCommon.BLOCKS.register("modern_white_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.OAK_DOOR));
    });

    @AutoRegister(name = "modern_white_door", itemClass = DoubleHighBlockItem.class, tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_MODERN_WHITE_DOOR = ModernLifeCommon.ITEMS.register("modern_white_door", () -> {
        return new DoubleHighBlockItem(BLOCK_MODERN_WHITE_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "birch_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_BIRCH_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("birch_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "birch_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_BIRCH_GLASS_DOOR = ModernLifeCommon.ITEMS.register("birch_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_BIRCH_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "crimson_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_CRIMSON_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("crimson_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "crimson_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_CRIMSON_GLASS_DOOR = ModernLifeCommon.ITEMS.register("crimson_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_CRIMSON_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "dark_oak_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_DARK_OAK_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("dark_oak_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "dark_oak_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_DARK_OAK_GLASS_DOOR = ModernLifeCommon.ITEMS.register("dark_oak_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_DARK_OAK_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_GLASS_DOOR = ModernLifeCommon.ITEMS.register("glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "iron_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_IRON_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("iron_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_DOOR));
    });

    @AutoRegister(name = "iron_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_IRON_GLASS_DOOR = ModernLifeCommon.ITEMS.register("iron_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_IRON_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "jungle_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_JUNGLE_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("jungle_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "jungle_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_JUNGLE_GLASS_DOOR = ModernLifeCommon.ITEMS.register("jungle_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_JUNGLE_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "oak_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_OAK_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("oak_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "oak_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_OAK_GLASS_DOOR = ModernLifeCommon.ITEMS.register("oak_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_OAK_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "spruce_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_SPRUCE_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("spruce_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "spruce_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_SPRUCE_GLASS_DOOR = ModernLifeCommon.ITEMS.register("spruce_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_SPRUCE_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "warped_glass_door", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_WARPED_GLASS_DOOR = ModernLifeCommon.BLOCKS.register("warped_glass_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_DOOR));
    });

    @AutoRegister(name = "warped_glass_door", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_WARPED_GLASS_DOOR = ModernLifeCommon.ITEMS.register("warped_glass_door", () -> {
        return new DoubleHighBlockItem(BLOCK_WARPED_GLASS_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "acacia_wall_shelf")
    public static RegistryObject<Block> BLOCK_ACACIA_WALL_SHELF = ModernLifeCommon.BLOCKS.register("acacia_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_wall_shelf")
    public static RegistryObject<Item> ITEM_ACACIA_WALL_SHELF = ModernLifeCommon.ITEMS.register("acacia_wall_shelf", () -> {
        return new BlockItem(BLOCK_ACACIA_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "birch_wall_shelf")
    public static RegistryObject<Block> BLOCK_BIRCH_WALL_SHELF = ModernLifeCommon.BLOCKS.register("birch_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_wall_shelf")
    public static RegistryObject<Item> ITEM_BIRCH_WALL_SHELF = ModernLifeCommon.ITEMS.register("birch_wall_shelf", () -> {
        return new BlockItem(BLOCK_BIRCH_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "crimson_wall_shelf")
    public static RegistryObject<Block> BLOCK_CRIMSON_WALL_SHELF = ModernLifeCommon.BLOCKS.register("crimson_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_wall_shelf")
    public static RegistryObject<Item> ITEM_CRIMSON_WALL_SHELF = ModernLifeCommon.ITEMS.register("crimson_wall_shelf", () -> {
        return new BlockItem(BLOCK_CRIMSON_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dark_oak_wall_shelf")
    public static RegistryObject<Block> BLOCK_DARK_OAK_WALL_SHELF = ModernLifeCommon.BLOCKS.register("dark_oak_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_wall_shelf")
    public static RegistryObject<Item> ITEM_DARK_OAK_WALL_SHELF = ModernLifeCommon.ITEMS.register("dark_oak_wall_shelf", () -> {
        return new BlockItem(BLOCK_DARK_OAK_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "jungle_wall_shelf")
    public static RegistryObject<Block> BLOCK_JUNGLE_WALL_SHELF = ModernLifeCommon.BLOCKS.register("jungle_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_wall_shelf")
    public static RegistryObject<Item> ITEM_JUNGLE_WALL_SHELF = ModernLifeCommon.ITEMS.register("jungle_wall_shelf", () -> {
        return new BlockItem(BLOCK_JUNGLE_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "oak_wall_shelf")
    public static RegistryObject<Block> BLOCK_OAK_WALL_SHELF = ModernLifeCommon.BLOCKS.register("oak_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_wall_shelf")
    public static RegistryObject<Item> ITEM_OAK_WALL_SHELF = ModernLifeCommon.ITEMS.register("oak_wall_shelf", () -> {
        return new BlockItem(BLOCK_OAK_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "spruce_wall_shelf")
    public static RegistryObject<Block> BLOCK_SPRUCE_WALL_SHELF = ModernLifeCommon.BLOCKS.register("spruce_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_wall_shelf")
    public static RegistryObject<Item> ITEM_SPRUCE_WALL_SHELF = ModernLifeCommon.ITEMS.register("spruce_wall_shelf", () -> {
        return new BlockItem(BLOCK_SPRUCE_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "warped_wall_shelf")
    public static RegistryObject<Block> BLOCK_WARPED_WALL_SHELF = ModernLifeCommon.BLOCKS.register("warped_wall_shelf", () -> {
        return new WallShelfBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_wall_shelf")
    public static RegistryObject<Item> ITEM_WARPED_WALL_SHELF = ModernLifeCommon.ITEMS.register("warped_wall_shelf", () -> {
        return new BlockItem(BLOCK_WARPED_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_acacia_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_ACACIA_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_acacia_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "double_acacia_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_ACACIA_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_acacia_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_ACACIA_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_birch_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_BIRCH_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_birch_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "double_birch_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_BIRCH_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_birch_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_BIRCH_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_crimson_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_CRIMSON_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_crimson_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "double_crimson_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_CRIMSON_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_crimson_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_CRIMSON_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_dark_oak_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_DARK_OAK_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_dark_oak_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "double_dark_oak_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_DARK_OAK_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_dark_oak_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_DARK_OAK_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_jungle_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_JUNGLE_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_jungle_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "double_jungle_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_JUNGLE_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_jungle_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_JUNGLE_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_oak_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_OAK_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_oak_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "double_oak_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_OAK_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_oak_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_OAK_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_spruce_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_SPRUCE_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_spruce_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "double_spruce_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_SPRUCE_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_spruce_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_SPRUCE_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "double_warped_wall_shelf")
    public static RegistryObject<Block> BLOCK_DOUBLE_WARPED_WALL_SHELF = ModernLifeCommon.BLOCKS.register("double_warped_wall_shelf", () -> {
        return new DoubleWallShelfBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "double_warped_wall_shelf")
    public static RegistryObject<Item> ITEM_DOUBLE_WARPED_WALL_SHELF = ModernLifeCommon.ITEMS.register("double_warped_wall_shelf", () -> {
        return new BlockItem(BLOCK_DOUBLE_WARPED_WALL_SHELF.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dishwasher")
    public static RegistryObject<Block> BLOCK_DISHWASHER = ModernLifeCommon.BLOCKS.register("dishwasher", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "dishwasher")
    public static RegistryObject<Item> ITEM_DISHWASHER = ModernLifeCommon.ITEMS.register("dishwasher", () -> {
        return new BlockItem(BLOCK_DISHWASHER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "kitchen_sink", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_KITCHEN_SINK = ModernLifeCommon.BLOCKS.register("kitchen_sink", () -> {
        return new KitchenSinkBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "kitchen_sink")
    public static RegistryObject<Item> ITEM_KITCHEN_SINK = ModernLifeCommon.ITEMS.register("kitchen_sink", () -> {
        return new BlockItem(BLOCK_KITCHEN_SINK.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_ACACIA_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("acacia_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_ACACIA_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("acacia_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_ACACIA_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_BIRCH_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("birch_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_BIRCH_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("birch_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_BIRCH_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CRIMSON_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("crimson_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CRIMSON_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("crimson_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CRIMSON_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_DARK_OAK_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("dark_oak_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_DARK_OAK_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("dark_oak_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_DARK_OAK_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_JUNGLE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("jungle_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_JUNGLE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("jungle_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_JUNGLE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_OAK_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("oak_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_OAK_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("oak_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_OAK_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_SPRUCE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("spruce_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_SPRUCE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("spruce_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_SPRUCE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_WARPED_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("warped_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_WARPED_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("warped_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_WARPED_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cobblestone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_COBBLESTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("cobblestone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "cobblestone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_COBBLESTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("cobblestone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_COBBLESTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "stone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_STONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("stone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.STONE));
    });

    @AutoRegister(name = "stone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_STONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("stone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_STONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "stone_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("stone_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.STONE_BRICKS));
    });

    @AutoRegister(name = "stone_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("stone_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_STONE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cracked_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CRACKED_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("cracked_stone_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CRACKED_STONE_BRICKS));
    });

    @AutoRegister(name = "cracked_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CRACKED_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("cracked_stone_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CRACKED_STONE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "mossy_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_MOSSY_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("mossy_stone_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_STONE_BRICKS));
    });

    @AutoRegister(name = "mossy_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_MOSSY_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("mossy_stone_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_MOSSY_STONE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_stone_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_STONE_BRICKS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_STONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("chiseled_stone_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_STONE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "clay_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CLAY_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("clay_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "clay_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CLAY_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("clay_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CLAY_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "sand_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_SAND_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("sand_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SAND));
    });

    @AutoRegister(name = "sand_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_SAND_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("sand_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_SAND_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "red_sand_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_RED_SAND_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("red_sand_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.RED_SAND));
    });

    @AutoRegister(name = "red_sand_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_RED_SAND_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("red_sand_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_RED_SAND_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "smooth_stone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_SMOOTH_STONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("smooth_stone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SMOOTH_STONE));
    });

    @AutoRegister(name = "smooth_stone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_SMOOTH_STONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("smooth_stone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_SMOOTH_STONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "gravel_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_GRAVEL_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("gravel_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.GRAVEL));
    });

    @AutoRegister(name = "gravel_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_GRAVEL_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("gravel_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_GRAVEL_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "granite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_GRANITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("granite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.GRANITE));
    });

    @AutoRegister(name = "granite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_GRANITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("granite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_GRANITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_granite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_GRANITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("polished_granite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_GRANITE));
    });

    @AutoRegister(name = "polished_granite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_GRANITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("polished_granite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_GRANITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "diorite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_DIORITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("diorite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DIORITE));
    });

    @AutoRegister(name = "diorite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_DIORITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("diorite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_DIORITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_diorite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_DIORITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("polished_diorite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_DIORITE));
    });

    @AutoRegister(name = "polished_diorite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_DIORITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("polished_diorite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_DIORITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "obsidian_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_OBSIDIAN_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("obsidian_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.OBSIDIAN));
    });

    @AutoRegister(name = "obsidian_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_OBSIDIAN_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("obsidian_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_OBSIDIAN_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "andesite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_ANDESITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("andesite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.ANDESITE));
    });

    @AutoRegister(name = "andesite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_ANDESITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("andesite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_ANDESITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_andesite_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_ANDESITE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("polished_andesite_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_ANDESITE));
    });

    @AutoRegister(name = "polished_andesite_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_ANDESITE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("polished_andesite_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_ANDESITE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "mossy_cobblestone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_MOSSY_COBBLESTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("mossy_cobblestone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_COBBLESTONE));
    });

    @AutoRegister(name = "mossy_cobblestone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_MOSSY_COBBLESTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("mossy_cobblestone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_MOSSY_COBBLESTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BRICKS));
    });

    @AutoRegister(name = "bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "terracotta_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_TERRACOTTA_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("terracotta_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.TERRACOTTA));
    });

    @AutoRegister(name = "terracotta_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_TERRACOTTA_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("terracotta_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_TERRACOTTA_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SANDSTONE));
    });

    @AutoRegister(name = "sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("chiseled_sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cut_sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CUT_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("cut_sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CUT_SANDSTONE));
    });

    @AutoRegister(name = "cut_sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CUT_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("cut_sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CUT_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "red_sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("red_sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.RED_SANDSTONE));
    });

    @AutoRegister(name = "red_sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("red_sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_RED_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_red_sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_red_sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_RED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_red_sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("chiseled_red_sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_RED_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cut_red_sandstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CUT_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("cut_red_sandstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CUT_RED_SANDSTONE));
    });

    @AutoRegister(name = "cut_red_sandstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CUT_RED_SANDSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("cut_red_sandstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CUT_RED_SANDSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "prismarine_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_PRISMARINE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("prismarine_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE));
    });

    @AutoRegister(name = "prismarine_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_PRISMARINE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("prismarine_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_PRISMARINE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "prismarine_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_PRISMARINE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("prismarine_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE_BRICKS));
    });

    @AutoRegister(name = "prismarine_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_PRISMARINE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("prismarine_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_PRISMARINE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_prismarine_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_DARK_PRISMARINE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("dark_prismarine_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DARK_PRISMARINE));
    });

    @AutoRegister(name = "dark_prismarine_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_DARK_PRISMARINE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("dark_prismarine_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_DARK_PRISMARINE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "blackstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("blackstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BLACKSTONE));
    });

    @AutoRegister(name = "blackstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("blackstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_BLACKSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_blackstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("polished_blackstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "polished_blackstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("polished_blackstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("polished_blackstone_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE_BRICKS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("polished_blackstone_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_POLISHED_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_polished_blackstone_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_POLISHED_BLACKSTONE_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("chiseled_polished_blackstone_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_POLISHED_BLACKSTONE_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "netherrack_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_NETHERRACK_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("netherrack_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.NETHERRACK));
    });

    @AutoRegister(name = "netherrack_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_NETHERRACK_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("netherrack_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_NETHERRACK_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "nether_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_NETHER_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("nether_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.NETHER_BRICKS));
    });

    @AutoRegister(name = "nether_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_NETHER_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("nether_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_NETHER_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_kitchen_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_NETHER_BRICKS_KITCHEN_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_nether_bricks_kitchen_cabinet", () -> {
        return new KitchenCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_NETHER_BRICKS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_kitchen_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_NETHER_BRICKS_KITCHEN_CABINET = ModernLifeCommon.ITEMS.register("chiseled_nether_bricks_kitchen_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_NETHER_BRICKS_KITCHEN_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_ACACIA_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("acacia_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_ACACIA_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("acacia_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_ACACIA_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_BIRCH_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("birch_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_BIRCH_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("birch_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_BIRCH_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CRIMSON_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("crimson_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CRIMSON_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("crimson_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CRIMSON_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_DARK_OAK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("dark_oak_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_DARK_OAK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("dark_oak_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_DARK_OAK_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_JUNGLE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("jungle_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_JUNGLE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("jungle_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_JUNGLE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_OAK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("oak_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_OAK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("oak_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_OAK_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_SPRUCE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("spruce_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_SPRUCE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("spruce_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_SPRUCE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_WARPED_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("warped_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_WARPED_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("warped_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_WARPED_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cobblestone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_COBBLESTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("cobblestone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "cobblestone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_COBBLESTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("cobblestone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_COBBLESTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "stone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_STONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("stone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.STONE));
    });

    @AutoRegister(name = "stone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_STONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("stone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_STONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("stone_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.STONE_BRICKS));
    });

    @AutoRegister(name = "stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("stone_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_STONE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cracked_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CRACKED_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("cracked_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CRACKED_STONE_BRICKS));
    });

    @AutoRegister(name = "cracked_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CRACKED_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("cracked_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CRACKED_STONE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "mossy_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_MOSSY_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("mossy_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_STONE_BRICKS));
    });

    @AutoRegister(name = "mossy_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_MOSSY_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("mossy_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_MOSSY_STONE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_STONE_BRICKS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_STONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("chiseled_stone_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_STONE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "clay_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CLAY_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("clay_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "clay_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CLAY_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("clay_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CLAY_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "sand_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_SAND_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("sand_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SAND));
    });

    @AutoRegister(name = "sand_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_SAND_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("sand_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_SAND_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "red_sand_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_RED_SAND_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("red_sand_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.RED_SAND));
    });

    @AutoRegister(name = "red_sand_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_RED_SAND_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("red_sand_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_RED_SAND_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "smooth_stone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_SMOOTH_STONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("smooth_stone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SMOOTH_STONE));
    });

    @AutoRegister(name = "smooth_stone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_SMOOTH_STONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("smooth_stone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_SMOOTH_STONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "gravel_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_GRAVEL_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("gravel_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.GRAVEL));
    });

    @AutoRegister(name = "gravel_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_GRAVEL_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("gravel_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_GRAVEL_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "granite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_GRANITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("granite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.GRANITE));
    });

    @AutoRegister(name = "granite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_GRANITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("granite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_GRANITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_granite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_GRANITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("polished_granite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_GRANITE));
    });

    @AutoRegister(name = "polished_granite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_GRANITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("polished_granite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_GRANITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "diorite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_DIORITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("diorite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DIORITE));
    });

    @AutoRegister(name = "diorite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_DIORITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("diorite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_DIORITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_diorite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_DIORITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("polished_diorite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_DIORITE));
    });

    @AutoRegister(name = "polished_diorite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_DIORITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("polished_diorite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_DIORITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "obsidian_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_OBSIDIAN_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("obsidian_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.OBSIDIAN));
    });

    @AutoRegister(name = "obsidian_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_OBSIDIAN_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("obsidian_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_OBSIDIAN_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "andesite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_ANDESITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("andesite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.ANDESITE));
    });

    @AutoRegister(name = "andesite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_ANDESITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("andesite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_ANDESITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_andesite_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_ANDESITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("polished_andesite_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_ANDESITE));
    });

    @AutoRegister(name = "polished_andesite_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_ANDESITE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("polished_andesite_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_ANDESITE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "mossy_cobblestone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_MOSSY_COBBLESTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("mossy_cobblestone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_COBBLESTONE));
    });

    @AutoRegister(name = "mossy_cobblestone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_MOSSY_COBBLESTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("mossy_cobblestone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_MOSSY_COBBLESTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BRICKS));
    });

    @AutoRegister(name = "bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "terracotta_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_TERRACOTTA_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("terracotta_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.TERRACOTTA));
    });

    @AutoRegister(name = "terracotta_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_TERRACOTTA_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("terracotta_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_TERRACOTTA_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.SANDSTONE));
    });

    @AutoRegister(name = "sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("chiseled_sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cut_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CUT_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("cut_sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CUT_SANDSTONE));
    });

    @AutoRegister(name = "cut_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CUT_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("cut_sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CUT_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("red_sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.RED_SANDSTONE));
    });

    @AutoRegister(name = "red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("red_sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_RED_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_red_sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_RED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("chiseled_red_sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_RED_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cut_red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CUT_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("cut_red_sandstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CUT_RED_SANDSTONE));
    });

    @AutoRegister(name = "cut_red_sandstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CUT_RED_SANDSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("cut_red_sandstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CUT_RED_SANDSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "prismarine_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_PRISMARINE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("prismarine_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE));
    });

    @AutoRegister(name = "prismarine_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_PRISMARINE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("prismarine_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_PRISMARINE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "prismarine_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_PRISMARINE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("prismarine_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE_BRICKS));
    });

    @AutoRegister(name = "prismarine_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_PRISMARINE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("prismarine_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_PRISMARINE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_prismarine_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_DARK_PRISMARINE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("dark_prismarine_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.DARK_PRISMARINE));
    });

    @AutoRegister(name = "dark_prismarine_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_DARK_PRISMARINE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("dark_prismarine_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_DARK_PRISMARINE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("blackstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.BLACKSTONE));
    });

    @AutoRegister(name = "blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("blackstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_BLACKSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("polished_blackstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "polished_blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("polished_blackstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("polished_blackstone_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE_BRICKS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("polished_blackstone_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_polished_blackstone_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("chiseled_polished_blackstone_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_POLISHED_BLACKSTONE_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "netherrack_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_NETHERRACK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("netherrack_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.NETHERRACK));
    });

    @AutoRegister(name = "netherrack_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_NETHERRACK_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("netherrack_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_NETHERRACK_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "nether_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_NETHER_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("nether_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.NETHER_BRICKS));
    });

    @AutoRegister(name = "nether_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_NETHER_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("nether_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_NETHER_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Block> BLOCK_CHISELED_NETHER_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.BLOCKS.register("chiseled_nether_bricks_kitchen_drawer_cabinet", () -> {
        return new KitchenDrawerCabinetBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_NETHER_BRICKS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_kitchen_drawer_cabinet")
    public static RegistryObject<Item> ITEM_CHISELED_NETHER_BRICKS_KITCHEN_DRAWER_CABINET = ModernLifeCommon.ITEMS.register("chiseled_nether_bricks_kitchen_drawer_cabinet", () -> {
        return new BlockItem(BLOCK_CHISELED_NETHER_BRICKS_KITCHEN_DRAWER_CABINET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cobblestone_ramp")
    public static RegistryObject<Block> BLOCK_COBBLESTONE_RAMP = ModernLifeCommon.BLOCKS.register("cobblestone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "cobblestone_ramp")
    public static RegistryObject<Item> ITEM_COBBLESTONE_RAMP = ModernLifeCommon.ITEMS.register("cobblestone_ramp", () -> {
        return new BlockItem(BLOCK_COBBLESTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stone_ramp")
    public static RegistryObject<Block> BLOCK_STONE_RAMP = ModernLifeCommon.BLOCKS.register("stone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STONE));
    });

    @AutoRegister(name = "stone_ramp")
    public static RegistryObject<Item> ITEM_STONE_RAMP = ModernLifeCommon.ITEMS.register("stone_ramp", () -> {
        return new BlockItem(BLOCK_STONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stone_bricks_ramp")
    public static RegistryObject<Block> BLOCK_STONE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("stone_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STONE_BRICKS));
    });

    @AutoRegister(name = "stone_bricks_ramp")
    public static RegistryObject<Item> ITEM_STONE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("stone_bricks_ramp", () -> {
        return new BlockItem(BLOCK_STONE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "cracked_stone_bricks_ramp")
    public static RegistryObject<Block> BLOCK_CRACKED_STONE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("cracked_stone_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CRACKED_STONE_BRICKS));
    });

    @AutoRegister(name = "cracked_stone_bricks_ramp")
    public static RegistryObject<Item> ITEM_CRACKED_STONE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("cracked_stone_bricks_ramp", () -> {
        return new BlockItem(BLOCK_CRACKED_STONE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "mossy_stone_bricks_ramp")
    public static RegistryObject<Block> BLOCK_MOSSY_STONE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("mossy_stone_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_STONE_BRICKS));
    });

    @AutoRegister(name = "mossy_stone_bricks_ramp")
    public static RegistryObject<Item> ITEM_MOSSY_STONE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("mossy_stone_bricks_ramp", () -> {
        return new BlockItem(BLOCK_MOSSY_STONE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_STONE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_stone_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_STONE_BRICKS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_STONE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("chiseled_stone_bricks_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_STONE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "clay_ramp")
    public static RegistryObject<Block> BLOCK_CLAY_RAMP = ModernLifeCommon.BLOCKS.register("clay_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "clay_ramp")
    public static RegistryObject<Item> ITEM_CLAY_RAMP = ModernLifeCommon.ITEMS.register("clay_ramp", () -> {
        return new BlockItem(BLOCK_CLAY_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "sand_ramp")
    public static RegistryObject<Block> BLOCK_SAND_RAMP = ModernLifeCommon.BLOCKS.register("sand_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SAND));
    });

    @AutoRegister(name = "sand_ramp")
    public static RegistryObject<Item> ITEM_SAND_RAMP = ModernLifeCommon.ITEMS.register("sand_ramp", () -> {
        return new BlockItem(BLOCK_SAND_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "red_sand_ramp")
    public static RegistryObject<Block> BLOCK_RED_SAND_RAMP = ModernLifeCommon.BLOCKS.register("red_sand_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.RED_SAND));
    });

    @AutoRegister(name = "red_sand_ramp")
    public static RegistryObject<Item> ITEM_RED_SAND_RAMP = ModernLifeCommon.ITEMS.register("red_sand_ramp", () -> {
        return new BlockItem(BLOCK_RED_SAND_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "smooth_stone_ramp")
    public static RegistryObject<Block> BLOCK_SMOOTH_STONE_RAMP = ModernLifeCommon.BLOCKS.register("smooth_stone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SMOOTH_STONE));
    });

    @AutoRegister(name = "smooth_stone_ramp")
    public static RegistryObject<Item> ITEM_SMOOTH_STONE_RAMP = ModernLifeCommon.ITEMS.register("smooth_stone_ramp", () -> {
        return new BlockItem(BLOCK_SMOOTH_STONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dirt_ramp")
    public static RegistryObject<Block> BLOCK_DIRT_RAMP = ModernLifeCommon.BLOCKS.register("dirt_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DIRT));
    });

    @AutoRegister(name = "dirt_ramp")
    public static RegistryObject<Item> ITEM_DIRT_RAMP = ModernLifeCommon.ITEMS.register("dirt_ramp", () -> {
        return new BlockItem(BLOCK_DIRT_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "deepslate_ramp")
    public static RegistryObject<Block> BLOCK_DEEPSLATE_RAMP = ModernLifeCommon.BLOCKS.register("deepslate_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DEEPSLATE));
    });

    @AutoRegister(name = "deepslate_ramp")
    public static RegistryObject<Item> ITEM_DEEPSLATE_RAMP = ModernLifeCommon.ITEMS.register("deepslate_ramp", () -> {
        return new BlockItem(BLOCK_DEEPSLATE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "cobbled_deepslate_ramp")
    public static RegistryObject<Block> BLOCK_COBBLED_DEEPSLATE_RAMP = ModernLifeCommon.BLOCKS.register("cobbled_deepslate_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.COBBLED_DEEPSLATE));
    });

    @AutoRegister(name = "cobbled_deepslate_ramp")
    public static RegistryObject<Item> ITEM_COBBLED_DEEPSLATE_RAMP = ModernLifeCommon.ITEMS.register("cobbled_deepslate_ramp", () -> {
        return new BlockItem(BLOCK_COBBLED_DEEPSLATE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "quartz_ramp")
    public static RegistryObject<Block> BLOCK_QUARTZ_RAMP = ModernLifeCommon.BLOCKS.register("quartz_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.QUARTZ_BLOCK));
    });

    @AutoRegister(name = "quartz_ramp")
    public static RegistryObject<Item> ITEM_QUARTZ_RAMP = ModernLifeCommon.ITEMS.register("quartz_ramp", () -> {
        return new BlockItem(BLOCK_QUARTZ_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "smooth_quartz_ramp")
    public static RegistryObject<Block> BLOCK_SMOOTH_QUARTZ_RAMP = ModernLifeCommon.BLOCKS.register("smooth_quartz_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SMOOTH_QUARTZ));
    });

    @AutoRegister(name = "smooth_quartz_ramp")
    public static RegistryObject<Item> ITEM_SMOOTH_QUARTZ_RAMP = ModernLifeCommon.ITEMS.register("smooth_quartz_ramp", () -> {
        return new BlockItem(BLOCK_SMOOTH_QUARTZ_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_quartz_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_QUARTZ_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_quartz_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_QUARTZ_BLOCK));
    });

    @AutoRegister(name = "chiseled_quartz_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_QUARTZ_RAMP = ModernLifeCommon.ITEMS.register("chiseled_quartz_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_QUARTZ_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "quartz_bricks_ramp")
    public static RegistryObject<Block> BLOCK_QUARTZ_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("quartz_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.QUARTZ_BRICKS));
    });

    @AutoRegister(name = "quartz_bricks_ramp")
    public static RegistryObject<Item> ITEM_QUARTZ_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("quartz_bricks_ramp", () -> {
        return new BlockItem(BLOCK_QUARTZ_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "quartz_pillar_ramp")
    public static RegistryObject<Block> BLOCK_QUARTZ_PILLAR_RAMP = ModernLifeCommon.BLOCKS.register("quartz_pillar_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.QUARTZ_PILLAR));
    });

    @AutoRegister(name = "quartz_pillar_ramp")
    public static RegistryObject<Item> ITEM_QUARTZ_PILLAR_RAMP = ModernLifeCommon.ITEMS.register("quartz_pillar_ramp", () -> {
        return new BlockItem(BLOCK_QUARTZ_PILLAR_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "glass_ramp", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_GLASS_RAMP = ModernLifeCommon.BLOCKS.register("glass_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_ramp")
    public static RegistryObject<Item> ITEM_GLASS_RAMP = ModernLifeCommon.ITEMS.register("glass_ramp", () -> {
        return new BlockItem(BLOCK_GLASS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "acacia_log_ramp")
    public static RegistryObject<Block> BLOCK_ACACIA_LOG_RAMP = ModernLifeCommon.BLOCKS.register("acacia_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_WOOD));
    });

    @AutoRegister(name = "acacia_log_ramp")
    public static RegistryObject<Item> ITEM_ACACIA_LOG_RAMP = ModernLifeCommon.ITEMS.register("acacia_log_ramp", () -> {
        return new BlockItem(BLOCK_ACACIA_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_acacia_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_ACACIA_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_acacia_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_ACACIA_WOOD));
    });

    @AutoRegister(name = "stripped_acacia_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_ACACIA_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_acacia_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_ACACIA_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "birch_log_ramp")
    public static RegistryObject<Block> BLOCK_BIRCH_LOG_RAMP = ModernLifeCommon.BLOCKS.register("birch_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_WOOD));
    });

    @AutoRegister(name = "birch_log_ramp")
    public static RegistryObject<Item> ITEM_BIRCH_LOG_RAMP = ModernLifeCommon.ITEMS.register("birch_log_ramp", () -> {
        return new BlockItem(BLOCK_BIRCH_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_birch_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_BIRCH_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_birch_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_BIRCH_WOOD));
    });

    @AutoRegister(name = "stripped_birch_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_BIRCH_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_birch_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_BIRCH_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "crimson_log_ramp")
    public static RegistryObject<Block> BLOCK_CRIMSON_LOG_RAMP = ModernLifeCommon.BLOCKS.register("crimson_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_STEM));
    });

    @AutoRegister(name = "crimson_log_ramp")
    public static RegistryObject<Item> ITEM_CRIMSON_LOG_RAMP = ModernLifeCommon.ITEMS.register("crimson_log_ramp", () -> {
        return new BlockItem(BLOCK_CRIMSON_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_crimson_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_CRIMSON_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_crimson_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_CRIMSON_STEM));
    });

    @AutoRegister(name = "stripped_crimson_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_CRIMSON_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_crimson_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_CRIMSON_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dark_oak_log_ramp")
    public static RegistryObject<Block> BLOCK_DARK_OAK_LOG_RAMP = ModernLifeCommon.BLOCKS.register("dark_oak_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_WOOD));
    });

    @AutoRegister(name = "dark_oak_log_ramp")
    public static RegistryObject<Item> ITEM_DARK_OAK_LOG_RAMP = ModernLifeCommon.ITEMS.register("dark_oak_log_ramp", () -> {
        return new BlockItem(BLOCK_DARK_OAK_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_dark_oak_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_DARK_OAK_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_dark_oak_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_DARK_OAK_WOOD));
    });

    @AutoRegister(name = "stripped_dark_oak_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_DARK_OAK_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_dark_oak_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_DARK_OAK_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "jungle_log_ramp")
    public static RegistryObject<Block> BLOCK_JUNGLE_LOG_RAMP = ModernLifeCommon.BLOCKS.register("jungle_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_WOOD));
    });

    @AutoRegister(name = "jungle_log_ramp")
    public static RegistryObject<Item> ITEM_JUNGLE_LOG_RAMP = ModernLifeCommon.ITEMS.register("jungle_log_ramp", () -> {
        return new BlockItem(BLOCK_JUNGLE_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_jungle_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_JUNGLE_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_jungle_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_JUNGLE_WOOD));
    });

    @AutoRegister(name = "stripped_jungle_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_JUNGLE_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_jungle_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_JUNGLE_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "oak_log_ramp")
    public static RegistryObject<Block> BLOCK_OAK_LOG_RAMP = ModernLifeCommon.BLOCKS.register("oak_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.OAK_WOOD));
    });

    @AutoRegister(name = "oak_log_ramp")
    public static RegistryObject<Item> ITEM_OAK_LOG_RAMP = ModernLifeCommon.ITEMS.register("oak_log_ramp", () -> {
        return new BlockItem(BLOCK_OAK_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_oak_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_OAK_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_oak_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_OAK_WOOD));
    });

    @AutoRegister(name = "stripped_oak_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_OAK_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_oak_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_OAK_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "spruce_log_ramp")
    public static RegistryObject<Block> BLOCK_SPRUCE_LOG_RAMP = ModernLifeCommon.BLOCKS.register("spruce_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_WOOD));
    });

    @AutoRegister(name = "spruce_log_ramp")
    public static RegistryObject<Item> ITEM_SPRUCE_LOG_RAMP = ModernLifeCommon.ITEMS.register("spruce_log_ramp", () -> {
        return new BlockItem(BLOCK_SPRUCE_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_spruce_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_SPRUCE_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_spruce_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_SPRUCE_WOOD));
    });

    @AutoRegister(name = "stripped_spruce_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_SPRUCE_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_spruce_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_SPRUCE_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "warped_log_ramp")
    public static RegistryObject<Block> BLOCK_WARPED_LOG_RAMP = ModernLifeCommon.BLOCKS.register("warped_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_STEM));
    });

    @AutoRegister(name = "warped_log_ramp")
    public static RegistryObject<Item> ITEM_WARPED_LOG_RAMP = ModernLifeCommon.ITEMS.register("warped_log_ramp", () -> {
        return new BlockItem(BLOCK_WARPED_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "stripped_warped_log_ramp")
    public static RegistryObject<Block> BLOCK_STRIPPED_WARPED_LOG_RAMP = ModernLifeCommon.BLOCKS.register("stripped_warped_log_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.STRIPPED_WARPED_STEM));
    });

    @AutoRegister(name = "stripped_warped_log_ramp")
    public static RegistryObject<Item> ITEM_STRIPPED_WARPED_LOG_RAMP = ModernLifeCommon.ITEMS.register("stripped_warped_log_ramp", () -> {
        return new BlockItem(BLOCK_STRIPPED_WARPED_LOG_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "gravel_ramp")
    public static RegistryObject<Block> BLOCK_GRAVEL_RAMP = ModernLifeCommon.BLOCKS.register("gravel_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.GRAVEL));
    });

    @AutoRegister(name = "gravel_ramp")
    public static RegistryObject<Item> ITEM_GRAVEL_RAMP = ModernLifeCommon.ITEMS.register("gravel_ramp", () -> {
        return new BlockItem(BLOCK_GRAVEL_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "granite_ramp")
    public static RegistryObject<Block> BLOCK_GRANITE_RAMP = ModernLifeCommon.BLOCKS.register("granite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.GRANITE));
    });

    @AutoRegister(name = "granite_ramp")
    public static RegistryObject<Item> ITEM_GRANITE_RAMP = ModernLifeCommon.ITEMS.register("granite_ramp", () -> {
        return new BlockItem(BLOCK_GRANITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "polished_granite_ramp")
    public static RegistryObject<Block> BLOCK_POLISHED_GRANITE_RAMP = ModernLifeCommon.BLOCKS.register("polished_granite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_GRANITE));
    });

    @AutoRegister(name = "polished_granite_ramp")
    public static RegistryObject<Item> ITEM_POLISHED_GRANITE_RAMP = ModernLifeCommon.ITEMS.register("polished_granite_ramp", () -> {
        return new BlockItem(BLOCK_POLISHED_GRANITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "diorite_ramp")
    public static RegistryObject<Block> BLOCK_DIORITE_RAMP = ModernLifeCommon.BLOCKS.register("diorite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DIORITE));
    });

    @AutoRegister(name = "diorite_ramp")
    public static RegistryObject<Item> ITEM_DIORITE_RAMP = ModernLifeCommon.ITEMS.register("diorite_ramp", () -> {
        return new BlockItem(BLOCK_DIORITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "polished_diorite_ramp")
    public static RegistryObject<Block> BLOCK_POLISHED_DIORITE_RAMP = ModernLifeCommon.BLOCKS.register("polished_diorite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_DIORITE));
    });

    @AutoRegister(name = "polished_diorite_ramp")
    public static RegistryObject<Item> ITEM_POLISHED_DIORITE_RAMP = ModernLifeCommon.ITEMS.register("polished_diorite_ramp", () -> {
        return new BlockItem(BLOCK_POLISHED_DIORITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "obsidian_ramp")
    public static RegistryObject<Block> BLOCK_OBSIDIAN_RAMP = ModernLifeCommon.BLOCKS.register("obsidian_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.OBSIDIAN));
    });

    @AutoRegister(name = "obsidian_ramp")
    public static RegistryObject<Item> ITEM_OBSIDIAN_RAMP = ModernLifeCommon.ITEMS.register("obsidian_ramp", () -> {
        return new BlockItem(BLOCK_OBSIDIAN_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "andesite_ramp")
    public static RegistryObject<Block> BLOCK_ANDESITE_RAMP = ModernLifeCommon.BLOCKS.register("andesite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.ANDESITE));
    });

    @AutoRegister(name = "andesite_ramp")
    public static RegistryObject<Item> ITEM_ANDESITE_RAMP = ModernLifeCommon.ITEMS.register("andesite_ramp", () -> {
        return new BlockItem(BLOCK_ANDESITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "polished_andesite_ramp")
    public static RegistryObject<Block> BLOCK_POLISHED_ANDESITE_RAMP = ModernLifeCommon.BLOCKS.register("polished_andesite_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_ANDESITE));
    });

    @AutoRegister(name = "polished_andesite_ramp")
    public static RegistryObject<Item> ITEM_POLISHED_ANDESITE_RAMP = ModernLifeCommon.ITEMS.register("polished_andesite_ramp", () -> {
        return new BlockItem(BLOCK_POLISHED_ANDESITE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "mossy_cobblestone_ramp")
    public static RegistryObject<Block> BLOCK_MOSSY_COBBLESTONE_RAMP = ModernLifeCommon.BLOCKS.register("mossy_cobblestone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_COBBLESTONE));
    });

    @AutoRegister(name = "mossy_cobblestone_ramp")
    public static RegistryObject<Item> ITEM_MOSSY_COBBLESTONE_RAMP = ModernLifeCommon.ITEMS.register("mossy_cobblestone_ramp", () -> {
        return new BlockItem(BLOCK_MOSSY_COBBLESTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "bricks_ramp")
    public static RegistryObject<Block> BLOCK_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.BRICKS));
    });

    @AutoRegister(name = "bricks_ramp")
    public static RegistryObject<Item> ITEM_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("bricks_ramp", () -> {
        return new BlockItem(BLOCK_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "terracotta_ramp")
    public static RegistryObject<Block> BLOCK_TERRACOTTA_RAMP = ModernLifeCommon.BLOCKS.register("terracotta_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.TERRACOTTA));
    });

    @AutoRegister(name = "terracotta_ramp")
    public static RegistryObject<Item> ITEM_TERRACOTTA_RAMP = ModernLifeCommon.ITEMS.register("terracotta_ramp", () -> {
        return new BlockItem(BLOCK_TERRACOTTA_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "sandstone_ramp")
    public static RegistryObject<Block> BLOCK_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SANDSTONE));
    });

    @AutoRegister(name = "sandstone_ramp")
    public static RegistryObject<Item> ITEM_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("sandstone_ramp", () -> {
        return new BlockItem(BLOCK_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_sandstone_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_sandstone_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("chiseled_sandstone_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "cut_sandstone_ramp")
    public static RegistryObject<Block> BLOCK_CUT_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("cut_sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CUT_SANDSTONE));
    });

    @AutoRegister(name = "cut_sandstone_ramp")
    public static RegistryObject<Item> ITEM_CUT_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("cut_sandstone_ramp", () -> {
        return new BlockItem(BLOCK_CUT_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "red_sandstone_ramp")
    public static RegistryObject<Block> BLOCK_RED_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("red_sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.RED_SANDSTONE));
    });

    @AutoRegister(name = "red_sandstone_ramp")
    public static RegistryObject<Item> ITEM_RED_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("red_sandstone_ramp", () -> {
        return new BlockItem(BLOCK_RED_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_red_sandstone_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_RED_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_red_sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_RED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_red_sandstone_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_RED_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("chiseled_red_sandstone_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_RED_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "cut_red_sandstone_ramp")
    public static RegistryObject<Block> BLOCK_CUT_RED_SANDSTONE_RAMP = ModernLifeCommon.BLOCKS.register("cut_red_sandstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CUT_RED_SANDSTONE));
    });

    @AutoRegister(name = "cut_red_sandstone_ramp")
    public static RegistryObject<Item> ITEM_CUT_RED_SANDSTONE_RAMP = ModernLifeCommon.ITEMS.register("cut_red_sandstone_ramp", () -> {
        return new BlockItem(BLOCK_CUT_RED_SANDSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "prismarine_ramp")
    public static RegistryObject<Block> BLOCK_PRISMARINE_RAMP = ModernLifeCommon.BLOCKS.register("prismarine_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE));
    });

    @AutoRegister(name = "prismarine_ramp")
    public static RegistryObject<Item> ITEM_PRISMARINE_RAMP = ModernLifeCommon.ITEMS.register("prismarine_ramp", () -> {
        return new BlockItem(BLOCK_PRISMARINE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "prismarine_bricks_ramp")
    public static RegistryObject<Block> BLOCK_PRISMARINE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("prismarine_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE_BRICKS));
    });

    @AutoRegister(name = "prismarine_bricks_ramp")
    public static RegistryObject<Item> ITEM_PRISMARINE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("prismarine_bricks_ramp", () -> {
        return new BlockItem(BLOCK_PRISMARINE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dark_prismarine_ramp")
    public static RegistryObject<Block> BLOCK_DARK_PRISMARINE_RAMP = ModernLifeCommon.BLOCKS.register("dark_prismarine_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DARK_PRISMARINE));
    });

    @AutoRegister(name = "dark_prismarine_ramp")
    public static RegistryObject<Item> ITEM_DARK_PRISMARINE_RAMP = ModernLifeCommon.ITEMS.register("dark_prismarine_ramp", () -> {
        return new BlockItem(BLOCK_DARK_PRISMARINE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "blackstone_ramp")
    public static RegistryObject<Block> BLOCK_BLACKSTONE_RAMP = ModernLifeCommon.BLOCKS.register("blackstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.BLACKSTONE));
    });

    @AutoRegister(name = "blackstone_ramp")
    public static RegistryObject<Item> ITEM_BLACKSTONE_RAMP = ModernLifeCommon.ITEMS.register("blackstone_ramp", () -> {
        return new BlockItem(BLOCK_BLACKSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "polished_blackstone_ramp")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_RAMP = ModernLifeCommon.BLOCKS.register("polished_blackstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "polished_blackstone_ramp")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_RAMP = ModernLifeCommon.ITEMS.register("polished_blackstone_ramp", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_ramp")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("polished_blackstone_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE_BRICKS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_ramp")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("polished_blackstone_bricks_ramp", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_POLISHED_BLACKSTONE_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_polished_blackstone_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_POLISHED_BLACKSTONE_RAMP = ModernLifeCommon.ITEMS.register("chiseled_polished_blackstone_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_POLISHED_BLACKSTONE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "netherrack_ramp")
    public static RegistryObject<Block> BLOCK_NETHERRACK_RAMP = ModernLifeCommon.BLOCKS.register("netherrack_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.NETHERRACK));
    });

    @AutoRegister(name = "netherrack_ramp")
    public static RegistryObject<Item> ITEM_NETHERRACK_RAMP = ModernLifeCommon.ITEMS.register("netherrack_ramp", () -> {
        return new BlockItem(BLOCK_NETHERRACK_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "nether_bricks_ramp")
    public static RegistryObject<Block> BLOCK_NETHER_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("nether_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.NETHER_BRICKS));
    });

    @AutoRegister(name = "nether_bricks_ramp")
    public static RegistryObject<Item> ITEM_NETHER_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("nether_bricks_ramp", () -> {
        return new BlockItem(BLOCK_NETHER_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_ramp")
    public static RegistryObject<Block> BLOCK_CHISELED_NETHER_BRICKS_RAMP = ModernLifeCommon.BLOCKS.register("chiseled_nether_bricks_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_NETHER_BRICKS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_ramp")
    public static RegistryObject<Item> ITEM_CHISELED_NETHER_BRICKS_RAMP = ModernLifeCommon.ITEMS.register("chiseled_nether_bricks_ramp", () -> {
        return new BlockItem(BLOCK_CHISELED_NETHER_BRICKS_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "acacia_ramp")
    public static RegistryObject<Block> BLOCK_ACACIA_RAMP = ModernLifeCommon.BLOCKS.register("acacia_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_ramp")
    public static RegistryObject<Item> ITEM_ACACIA_RAMP = ModernLifeCommon.ITEMS.register("acacia_ramp", () -> {
        return new BlockItem(BLOCK_ACACIA_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "birch_ramp")
    public static RegistryObject<Block> BLOCK_BIRCH_RAMP = ModernLifeCommon.BLOCKS.register("birch_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_ramp")
    public static RegistryObject<Item> ITEM_BIRCH_RAMP = ModernLifeCommon.ITEMS.register("birch_ramp", () -> {
        return new BlockItem(BLOCK_BIRCH_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "crimson_ramp")
    public static RegistryObject<Block> BLOCK_CRIMSON_RAMP = ModernLifeCommon.BLOCKS.register("crimson_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_ramp")
    public static RegistryObject<Item> ITEM_CRIMSON_RAMP = ModernLifeCommon.ITEMS.register("crimson_ramp", () -> {
        return new BlockItem(BLOCK_CRIMSON_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dark_oak_ramp")
    public static RegistryObject<Block> BLOCK_DARK_OAK_RAMP = ModernLifeCommon.BLOCKS.register("dark_oak_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_ramp")
    public static RegistryObject<Item> ITEM_DARK_OAK_RAMP = ModernLifeCommon.ITEMS.register("dark_oak_ramp", () -> {
        return new BlockItem(BLOCK_DARK_OAK_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "jungle_ramp")
    public static RegistryObject<Block> BLOCK_JUNGLE_RAMP = ModernLifeCommon.BLOCKS.register("jungle_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_ramp")
    public static RegistryObject<Item> ITEM_JUNGLE_RAMP = ModernLifeCommon.ITEMS.register("jungle_ramp", () -> {
        return new BlockItem(BLOCK_JUNGLE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "oak_ramp")
    public static RegistryObject<Block> BLOCK_OAK_RAMP = ModernLifeCommon.BLOCKS.register("oak_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_ramp")
    public static RegistryObject<Item> ITEM_OAK_RAMP = ModernLifeCommon.ITEMS.register("oak_ramp", () -> {
        return new BlockItem(BLOCK_OAK_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "spruce_ramp")
    public static RegistryObject<Block> BLOCK_SPRUCE_RAMP = ModernLifeCommon.BLOCKS.register("spruce_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_ramp")
    public static RegistryObject<Item> ITEM_SPRUCE_RAMP = ModernLifeCommon.ITEMS.register("spruce_ramp", () -> {
        return new BlockItem(BLOCK_SPRUCE_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "warped_ramp")
    public static RegistryObject<Block> BLOCK_WARPED_RAMP = ModernLifeCommon.BLOCKS.register("warped_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_ramp")
    public static RegistryObject<Item> ITEM_WARPED_RAMP = ModernLifeCommon.ITEMS.register("warped_ramp", () -> {
        return new BlockItem(BLOCK_WARPED_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "paved_road_ramp")
    public static RegistryObject<Block> BLOCK_PAVED_ROAD_RAMP = ModernLifeCommon.BLOCKS.register("paved_road_ramp", () -> {
        return new RampBlock(BlockBehaviour.Properties.copy(Blocks.BLACK_CONCRETE));
    });

    @AutoRegister(name = "paved_road_ramp")
    public static RegistryObject<Item> ITEM_PAVED_ROAD_RAMP = ModernLifeCommon.ITEMS.register("paved_road_ramp", () -> {
        return new BlockItem(BLOCK_PAVED_ROAD_RAMP.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "ceiling_fan", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_CEILING_FAN = ModernLifeCommon.BLOCKS.register("ceiling_fan", () -> {
        return new CeilingFanBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "ceiling_fan")
    public static RegistryObject<Item> ITEM_CEILING_FAN = ModernLifeCommon.ITEMS.register("ceiling_fan", () -> {
        return new BlockItem(BLOCK_CEILING_FAN.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jail_bars")
    public static RegistryObject<Block> BLOCK_JAIL_BARS = ModernLifeCommon.BLOCKS.register("jail_bars", () -> {
        return new JailBarsBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BARS));
    });

    @AutoRegister(name = "jail_bars")
    public static RegistryObject<Item> ITEM_JAIL_BARS = ModernLifeCommon.ITEMS.register("jail_bars", () -> {
        return new BlockItem(BLOCK_JAIL_BARS.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "jail_door", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_JAIL_DOOR = ModernLifeCommon.BLOCKS.register("jail_door", () -> {
        return new DoorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_DOOR));
    });

    @AutoRegister(name = "jail_door")
    public static RegistryObject<Item> ITEM_JAIL_DOOR = ModernLifeCommon.ITEMS.register("jail_door", () -> {
        return new DoubleHighBlockItem(BLOCK_JAIL_DOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "extractor", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_EXTRACTOR = ModernLifeCommon.BLOCKS.register("extractor", () -> {
        return new ExtractorBlock(BlockBehaviour.Properties.copy(Blocks.HOPPER));
    });

    @AutoRegister(name = "extractor")
    public static RegistryObject<Item> ITEM_EXTRACTOR = ModernLifeCommon.ITEMS.register("extractor", () -> {
        return new BlockItem(BLOCK_EXTRACTOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "acacia_night_stand")
    public static RegistryObject<Block> BLOCK_ACACIA_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("acacia_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "acacia_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ACACIA_NIGHT_STAND = ModernLifeCommon.ITEMS.register("acacia_night_stand", () -> {
        return new BlockItem(BLOCK_ACACIA_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_night_stand")
    public static RegistryObject<Block> BLOCK_BIRCH_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("birch_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "birch_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BIRCH_NIGHT_STAND = ModernLifeCommon.ITEMS.register("birch_night_stand", () -> {
        return new BlockItem(BLOCK_BIRCH_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_night_stand")
    public static RegistryObject<Block> BLOCK_CRIMSON_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("crimson_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "crimson_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CRIMSON_NIGHT_STAND = ModernLifeCommon.ITEMS.register("crimson_night_stand", () -> {
        return new BlockItem(BLOCK_CRIMSON_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_night_stand")
    public static RegistryObject<Block> BLOCK_DARK_OAK_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("dark_oak_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "dark_oak_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DARK_OAK_NIGHT_STAND = ModernLifeCommon.ITEMS.register("dark_oak_night_stand", () -> {
        return new BlockItem(BLOCK_DARK_OAK_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_night_stand")
    public static RegistryObject<Block> BLOCK_JUNGLE_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("jungle_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "jungle_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_JUNGLE_NIGHT_STAND = ModernLifeCommon.ITEMS.register("jungle_night_stand", () -> {
        return new BlockItem(BLOCK_JUNGLE_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_night_stand")
    public static RegistryObject<Block> BLOCK_OAK_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("oak_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "oak_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OAK_NIGHT_STAND = ModernLifeCommon.ITEMS.register("oak_night_stand", () -> {
        return new BlockItem(BLOCK_OAK_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_night_stand")
    public static RegistryObject<Block> BLOCK_SPRUCE_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("spruce_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "spruce_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SPRUCE_NIGHT_STAND = ModernLifeCommon.ITEMS.register("spruce_night_stand", () -> {
        return new BlockItem(BLOCK_SPRUCE_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_night_stand")
    public static RegistryObject<Block> BLOCK_WARPED_NIGHT_STAND = ModernLifeCommon.BLOCKS.register("warped_night_stand", () -> {
        return new NightStandBlock(BlockBehaviour.Properties.copy(Blocks.CRAFTING_TABLE));
    });

    @AutoRegister(name = "warped_night_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WARPED_NIGHT_STAND = ModernLifeCommon.ITEMS.register("warped_night_stand", () -> {
        return new BlockItem(BLOCK_WARPED_NIGHT_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "shower_head", blockClass = ShowerHeadBlock.class, material = "METAL", soundType = "METAL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_SHOWER_HEAD = ModernLifeCommon.BLOCKS.register("shower_head", () -> {
        return new ShowerHeadBlock(BlockBehaviour.Properties.of(Material.METAL).sound(SoundType.METAL).strength(1.5f));
    });

    @AutoRegister(name = "shower_head", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SHOWER_HEAD = ModernLifeCommon.ITEMS.register("shower_head", () -> {
        return new BlockItem(BLOCK_SHOWER_HEAD.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "alarm_clock")
    public static RegistryObject<Block> BLOCK_ALARM_CLOCK = ModernLifeCommon.BLOCKS.register("alarm_clock", () -> {
        return new AlarmClockBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "alarm_clock", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ALARM_CLOCK = ModernLifeCommon.ITEMS.register("alarm_clock", () -> {
        return new BlockItem(BLOCK_ALARM_CLOCK.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "electrical_outlet", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_ELECTRICAL_OUTLET = ModernLifeCommon.BLOCKS.register("electrical_outlet", () -> {
        return new WallSocketBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "electrical_outlet", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ELECTRICAL_OUTLET = ModernLifeCommon.ITEMS.register("electrical_outlet", () -> {
        return new BlockItem(BLOCK_ELECTRICAL_OUTLET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "air_conditioner", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_AIR_CONDITIONER = ModernLifeCommon.BLOCKS.register("air_conditioner", () -> {
        return new AirConditionerBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "air_conditioner", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_AIR_CONDITIONER = ModernLifeCommon.ITEMS.register("air_conditioner", () -> {
        return new BlockItem(BLOCK_AIR_CONDITIONER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "metal_duct")
    public static RegistryObject<Block> BLOCK_METAL_DUCT = ModernLifeCommon.BLOCKS.register("metal_duct", () -> {
        return new MetalDuctBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "metal_duct", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_METAL_DUCT = ModernLifeCommon.ITEMS.register("metal_duct", () -> {
        return new BlockItem(BLOCK_METAL_DUCT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "hot_water_heater")
    public static RegistryObject<Block> BLOCK_HOT_WATER_HEATER = ModernLifeCommon.BLOCKS.register("hot_water_heater", () -> {
        return new HotWaterHeaterBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "hot_water_heater", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_HOT_WATER_HEATER = ModernLifeCommon.ITEMS.register("hot_water_heater", () -> {
        return new BlockItem(BLOCK_HOT_WATER_HEATER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_panel", blockClass = GlassPanelBlock.class, material = "GLASS", soundType = "GLASS", strength = 1.0f, renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_PANEL = ModernLifeCommon.BLOCKS.register("glass_panel", () -> {
        return new GlassPanelBlock(BlockBehaviour.Properties.copy(Blocks.GLASS_PANE));
    });

    @AutoRegister(name = "glass_panel", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_PANEL = ModernLifeCommon.ITEMS.register("glass_panel", () -> {
        return new BlockItem(BLOCK_GLASS_PANEL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "tile_light", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_TILE_LIGHT = ModernLifeCommon.BLOCKS.register("tile_light", () -> {
        return new TileLightBlock(BlockBehaviour.Properties.of(Material.CLAY));
    });

    @AutoRegister(name = "tile_light", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_TILE_LIGHT = ModernLifeCommon.ITEMS.register("tile_light", () -> {
        return new BlockItem(BLOCK_TILE_LIGHT.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "metal_grate", blockClass = GrateBlock.class, material = "METAL", soundType = "METAL", strength = HandgunItem.handgunZoomFactor, renderType = "cutout")
    public static RegistryObject<Block> BLOCK_METAL_GRATE = ModernLifeCommon.BLOCKS.register("metal_grate", () -> {
        return new GrateBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "metal_grate", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_METAL_GRATE = ModernLifeCommon.ITEMS.register("metal_grate", () -> {
        return new BlockItem(BLOCK_METAL_GRATE.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "light_bulb", blockClass = LightBulbBlock.class, material = "GLASS", soundType = "GLASS", strength = 1.0f, renderType = "translucent")
    public static RegistryObject<Block> BLOCK_LIGHT_BULB = ModernLifeCommon.BLOCKS.register("light_bulb", () -> {
        return new LightBulbBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "light_bulb", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_LIGHT_BULB = ModernLifeCommon.ITEMS.register("light_bulb", () -> {
        return new BlockItem(BLOCK_LIGHT_BULB.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "arrow_slit", blockClass = LightBulbBlock.class, material = "STONE", soundType = "STONE", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_ARROW_SLIT = ModernLifeCommon.BLOCKS.register("arrow_slit", () -> {
        return new ArrowSlitBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "arrow_slit", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ARROW_SLIT = ModernLifeCommon.ITEMS.register("arrow_slit", () -> {
        return new BlockItem(BLOCK_ARROW_SLIT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "toilet", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_TOILET = ModernLifeCommon.BLOCKS.register("toilet", () -> {
        return new ToiletBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "toilet", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_TOILET = ModernLifeCommon.ITEMS.register("toilet", () -> {
        return new BlockItem(BLOCK_TOILET.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "black_sofa")
    public static RegistryObject<Block> BLOCK_BLACK_SOFA = ModernLifeCommon.BLOCKS.register("black_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.BLACK_WOOL));
    });

    @AutoRegister(name = "black_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BLACK_SOFA = ModernLifeCommon.ITEMS.register("black_sofa", () -> {
        return new BlockItem(BLOCK_BLACK_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "blue_sofa")
    public static RegistryObject<Block> BLOCK_BLUE_SOFA = ModernLifeCommon.BLOCKS.register("blue_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.BLUE_WOOL));
    });

    @AutoRegister(name = "blue_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BLUE_SOFA = ModernLifeCommon.ITEMS.register("blue_sofa", () -> {
        return new BlockItem(BLOCK_BLUE_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "brown_sofa")
    public static RegistryObject<Block> BLOCK_BROWN_SOFA = ModernLifeCommon.BLOCKS.register("brown_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.BROWN_WOOL));
    });

    @AutoRegister(name = "brown_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BROWN_SOFA = ModernLifeCommon.ITEMS.register("brown_sofa", () -> {
        return new BlockItem(BLOCK_BROWN_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "cyan_sofa")
    public static RegistryObject<Block> BLOCK_CYAN_SOFA = ModernLifeCommon.BLOCKS.register("cyan_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.CYAN_WOOL));
    });

    @AutoRegister(name = "cyan_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CYAN_SOFA = ModernLifeCommon.ITEMS.register("cyan_sofa", () -> {
        return new BlockItem(BLOCK_CYAN_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "gray_sofa")
    public static RegistryObject<Block> BLOCK_GRAY_SOFA = ModernLifeCommon.BLOCKS.register("gray_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.GRAY_WOOL));
    });

    @AutoRegister(name = "gray_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GRAY_SOFA = ModernLifeCommon.ITEMS.register("gray_sofa", () -> {
        return new BlockItem(BLOCK_GRAY_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "green_sofa")
    public static RegistryObject<Block> BLOCK_GREEN_SOFA = ModernLifeCommon.BLOCKS.register("green_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.GREEN_WOOL));
    });

    @AutoRegister(name = "green_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GREEN_SOFA = ModernLifeCommon.ITEMS.register("green_sofa", () -> {
        return new BlockItem(BLOCK_GREEN_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "light_blue_sofa")
    public static RegistryObject<Block> BLOCK_LIGHT_BLUE_SOFA = ModernLifeCommon.BLOCKS.register("light_blue_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.LIGHT_BLUE_WOOL));
    });

    @AutoRegister(name = "light_blue_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_LIGHT_BLUE_SOFA = ModernLifeCommon.ITEMS.register("light_blue_sofa", () -> {
        return new BlockItem(BLOCK_LIGHT_BLUE_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "light_gray_sofa")
    public static RegistryObject<Block> BLOCK_LIGHT_GRAY_SOFA = ModernLifeCommon.BLOCKS.register("light_gray_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.LIGHT_GRAY_WOOL));
    });

    @AutoRegister(name = "light_gray_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_LIGHT_GRAY_SOFA = ModernLifeCommon.ITEMS.register("light_gray_sofa", () -> {
        return new BlockItem(BLOCK_LIGHT_GRAY_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "lime_sofa")
    public static RegistryObject<Block> BLOCK_LIME_SOFA = ModernLifeCommon.BLOCKS.register("lime_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.LIME_WOOL));
    });

    @AutoRegister(name = "lime_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_LIME_SOFA = ModernLifeCommon.ITEMS.register("lime_sofa", () -> {
        return new BlockItem(BLOCK_LIME_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "magenta_sofa")
    public static RegistryObject<Block> BLOCK_MAGENTA_SOFA = ModernLifeCommon.BLOCKS.register("magenta_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.MAGENTA_WOOL));
    });

    @AutoRegister(name = "magenta_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_MAGENTA_SOFA = ModernLifeCommon.ITEMS.register("magenta_sofa", () -> {
        return new BlockItem(BLOCK_MAGENTA_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "orange_sofa")
    public static RegistryObject<Block> BLOCK_ORANGE_SOFA = ModernLifeCommon.BLOCKS.register("orange_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.ORANGE_WOOL));
    });

    @AutoRegister(name = "orange_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ORANGE_SOFA = ModernLifeCommon.ITEMS.register("orange_sofa", () -> {
        return new BlockItem(BLOCK_ORANGE_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "pink_sofa")
    public static RegistryObject<Block> BLOCK_PINK_SOFA = ModernLifeCommon.BLOCKS.register("pink_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.PINK_WOOL));
    });

    @AutoRegister(name = "pink_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_PINK_SOFA = ModernLifeCommon.ITEMS.register("pink_sofa", () -> {
        return new BlockItem(BLOCK_PINK_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "purple_sofa")
    public static RegistryObject<Block> BLOCK_PURPLE_SOFA = ModernLifeCommon.BLOCKS.register("purple_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.PURPLE_WOOL));
    });

    @AutoRegister(name = "purple_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_PURPLE_SOFA = ModernLifeCommon.ITEMS.register("purple_sofa", () -> {
        return new BlockItem(BLOCK_PURPLE_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "red_sofa")
    public static RegistryObject<Block> BLOCK_RED_SOFA = ModernLifeCommon.BLOCKS.register("red_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.RED_WOOL));
    });

    @AutoRegister(name = "red_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_RED_SOFA = ModernLifeCommon.ITEMS.register("red_sofa", () -> {
        return new BlockItem(BLOCK_RED_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "white_sofa")
    public static RegistryObject<Block> BLOCK_WHITE_SOFA = ModernLifeCommon.BLOCKS.register("white_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_WOOL));
    });

    @AutoRegister(name = "white_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WHITE_SOFA = ModernLifeCommon.ITEMS.register("white_sofa", () -> {
        return new BlockItem(BLOCK_WHITE_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "yellow_sofa")
    public static RegistryObject<Block> BLOCK_YELLOW_SOFA = ModernLifeCommon.BLOCKS.register("yellow_sofa", () -> {
        return new SofaBlock(BlockBehaviour.Properties.copy(Blocks.YELLOW_WOOL));
    });

    @AutoRegister(name = "yellow_sofa", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_YELLOW_SOFA = ModernLifeCommon.ITEMS.register("yellow_sofa", () -> {
        return new BlockItem(BLOCK_YELLOW_SOFA.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_barrier")
    public static RegistryObject<Block> BLOCK_ACACIA_BARRIER = ModernLifeCommon.BLOCKS.register("acacia_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_ACACIA_BARRIER = ModernLifeCommon.ITEMS.register("acacia_barrier", () -> {
        return new BlockItem(BLOCK_ACACIA_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "birch_barrier")
    public static RegistryObject<Block> BLOCK_BIRCH_BARRIER = ModernLifeCommon.BLOCKS.register("birch_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_BIRCH_BARRIER = ModernLifeCommon.ITEMS.register("birch_barrier", () -> {
        return new BlockItem(BLOCK_BIRCH_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "crimson_barrier")
    public static RegistryObject<Block> BLOCK_CRIMSON_BARRIER = ModernLifeCommon.BLOCKS.register("crimson_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CRIMSON_BARRIER = ModernLifeCommon.ITEMS.register("crimson_barrier", () -> {
        return new BlockItem(BLOCK_CRIMSON_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "dark_oak_barrier")
    public static RegistryObject<Block> BLOCK_DARK_OAK_BARRIER = ModernLifeCommon.BLOCKS.register("dark_oak_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_DARK_OAK_BARRIER = ModernLifeCommon.ITEMS.register("dark_oak_barrier", () -> {
        return new BlockItem(BLOCK_DARK_OAK_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "jungle_barrier")
    public static RegistryObject<Block> BLOCK_JUNGLE_BARRIER = ModernLifeCommon.BLOCKS.register("jungle_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_JUNGLE_BARRIER = ModernLifeCommon.ITEMS.register("jungle_barrier", () -> {
        return new BlockItem(BLOCK_JUNGLE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "oak_barrier")
    public static RegistryObject<Block> BLOCK_OAK_BARRIER = ModernLifeCommon.BLOCKS.register("oak_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_OAK_BARRIER = ModernLifeCommon.ITEMS.register("oak_barrier", () -> {
        return new BlockItem(BLOCK_OAK_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "spruce_barrier")
    public static RegistryObject<Block> BLOCK_SPRUCE_BARRIER = ModernLifeCommon.BLOCKS.register("spruce_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_SPRUCE_BARRIER = ModernLifeCommon.ITEMS.register("spruce_barrier", () -> {
        return new BlockItem(BLOCK_SPRUCE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "warped_barrier")
    public static RegistryObject<Block> BLOCK_WARPED_BARRIER = ModernLifeCommon.BLOCKS.register("warped_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_WARPED_BARRIER = ModernLifeCommon.ITEMS.register("warped_barrier", () -> {
        return new BlockItem(BLOCK_WARPED_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "cobblestone_barrier")
    public static RegistryObject<Block> BLOCK_COBBLESTONE_BARRIER = ModernLifeCommon.BLOCKS.register("cobblestone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "cobblestone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_COBBLESTONE_BARRIER = ModernLifeCommon.ITEMS.register("cobblestone_barrier", () -> {
        return new BlockItem(BLOCK_COBBLESTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "stone_barrier")
    public static RegistryObject<Block> BLOCK_STONE_BARRIER = ModernLifeCommon.BLOCKS.register("stone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.STONE));
    });

    @AutoRegister(name = "stone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_STONE_BARRIER = ModernLifeCommon.ITEMS.register("stone_barrier", () -> {
        return new BlockItem(BLOCK_STONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "stone_bricks_barrier")
    public static RegistryObject<Block> BLOCK_STONE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("stone_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.STONE_BRICKS));
    });

    @AutoRegister(name = "stone_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_STONE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("stone_bricks_barrier", () -> {
        return new BlockItem(BLOCK_STONE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "cracked_stone_bricks_barrier")
    public static RegistryObject<Block> BLOCK_CRACKED_STONE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("cracked_stone_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CRACKED_STONE_BRICKS));
    });

    @AutoRegister(name = "cracked_stone_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CRACKED_STONE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("cracked_stone_bricks_barrier", () -> {
        return new BlockItem(BLOCK_CRACKED_STONE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "mossy_stone_bricks_barrier")
    public static RegistryObject<Block> BLOCK_MOSSY_STONE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("mossy_stone_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_STONE_BRICKS));
    });

    @AutoRegister(name = "mossy_stone_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_MOSSY_STONE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("mossy_stone_bricks_barrier", () -> {
        return new BlockItem(BLOCK_MOSSY_STONE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chiseled_stone_bricks_barrier")
    public static RegistryObject<Block> BLOCK_CHISELED_STONE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("chiseled_stone_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_STONE_BRICKS));
    });

    @AutoRegister(name = "chiseled_stone_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHISELED_STONE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("chiseled_stone_bricks_barrier", () -> {
        return new BlockItem(BLOCK_CHISELED_STONE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "clay_barrier")
    public static RegistryObject<Block> BLOCK_CLAY_BARRIER = ModernLifeCommon.BLOCKS.register("clay_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "clay_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CLAY_BARRIER = ModernLifeCommon.ITEMS.register("clay_barrier", () -> {
        return new BlockItem(BLOCK_CLAY_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "sand_barrier")
    public static RegistryObject<Block> BLOCK_SAND_BARRIER = ModernLifeCommon.BLOCKS.register("sand_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.SAND));
    });

    @AutoRegister(name = "sand_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_SAND_BARRIER = ModernLifeCommon.ITEMS.register("sand_barrier", () -> {
        return new BlockItem(BLOCK_SAND_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "red_sand_barrier")
    public static RegistryObject<Block> BLOCK_RED_SAND_BARRIER = ModernLifeCommon.BLOCKS.register("red_sand_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.RED_SAND));
    });

    @AutoRegister(name = "red_sand_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_RED_SAND_BARRIER = ModernLifeCommon.ITEMS.register("red_sand_barrier", () -> {
        return new BlockItem(BLOCK_RED_SAND_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "smooth_stone_barrier")
    public static RegistryObject<Block> BLOCK_SMOOTH_STONE_BARRIER = ModernLifeCommon.BLOCKS.register("smooth_stone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.SMOOTH_STONE));
    });

    @AutoRegister(name = "smooth_stone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_SMOOTH_STONE_BARRIER = ModernLifeCommon.ITEMS.register("smooth_stone_barrier", () -> {
        return new BlockItem(BLOCK_SMOOTH_STONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "gravel_barrier")
    public static RegistryObject<Block> BLOCK_GRAVEL_BARRIER = ModernLifeCommon.BLOCKS.register("gravel_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.GRAVEL));
    });

    @AutoRegister(name = "gravel_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_GRAVEL_BARRIER = ModernLifeCommon.ITEMS.register("gravel_barrier", () -> {
        return new BlockItem(BLOCK_GRAVEL_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "granite_barrier")
    public static RegistryObject<Block> BLOCK_GRANITE_BARRIER = ModernLifeCommon.BLOCKS.register("granite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.GRANITE));
    });

    @AutoRegister(name = "granite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_GRANITE_BARRIER = ModernLifeCommon.ITEMS.register("granite_barrier", () -> {
        return new BlockItem(BLOCK_GRANITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "polished_granite_barrier")
    public static RegistryObject<Block> BLOCK_POLISHED_GRANITE_BARRIER = ModernLifeCommon.BLOCKS.register("polished_granite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_GRANITE));
    });

    @AutoRegister(name = "polished_granite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_POLISHED_GRANITE_BARRIER = ModernLifeCommon.ITEMS.register("polished_granite_barrier", () -> {
        return new BlockItem(BLOCK_POLISHED_GRANITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "diorite_barrier")
    public static RegistryObject<Block> BLOCK_DIORITE_BARRIER = ModernLifeCommon.BLOCKS.register("diorite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.DIORITE));
    });

    @AutoRegister(name = "diorite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_DIORITE_BARRIER = ModernLifeCommon.ITEMS.register("diorite_barrier", () -> {
        return new BlockItem(BLOCK_DIORITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "polished_diorite_barrier")
    public static RegistryObject<Block> BLOCK_POLISHED_DIORITE_BARRIER = ModernLifeCommon.BLOCKS.register("polished_diorite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_DIORITE));
    });

    @AutoRegister(name = "polished_diorite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_POLISHED_DIORITE_BARRIER = ModernLifeCommon.ITEMS.register("polished_diorite_barrier", () -> {
        return new BlockItem(BLOCK_POLISHED_DIORITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "obsidian_barrier")
    public static RegistryObject<Block> BLOCK_OBSIDIAN_BARRIER = ModernLifeCommon.BLOCKS.register("obsidian_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.OBSIDIAN));
    });

    @AutoRegister(name = "obsidian_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_OBSIDIAN_BARRIER = ModernLifeCommon.ITEMS.register("obsidian_barrier", () -> {
        return new BlockItem(BLOCK_OBSIDIAN_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "andesite_barrier")
    public static RegistryObject<Block> BLOCK_ANDESITE_BARRIER = ModernLifeCommon.BLOCKS.register("andesite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.ANDESITE));
    });

    @AutoRegister(name = "andesite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_ANDESITE_BARRIER = ModernLifeCommon.ITEMS.register("andesite_barrier", () -> {
        return new BlockItem(BLOCK_ANDESITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "polished_andesite_barrier")
    public static RegistryObject<Block> BLOCK_POLISHED_ANDESITE_BARRIER = ModernLifeCommon.BLOCKS.register("polished_andesite_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_ANDESITE));
    });

    @AutoRegister(name = "polished_andesite_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_POLISHED_ANDESITE_BARRIER = ModernLifeCommon.ITEMS.register("polished_andesite_barrier", () -> {
        return new BlockItem(BLOCK_POLISHED_ANDESITE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "mossy_cobblestone_barrier")
    public static RegistryObject<Block> BLOCK_MOSSY_COBBLESTONE_BARRIER = ModernLifeCommon.BLOCKS.register("mossy_cobblestone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.MOSSY_COBBLESTONE));
    });

    @AutoRegister(name = "mossy_cobblestone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_MOSSY_COBBLESTONE_BARRIER = ModernLifeCommon.ITEMS.register("mossy_cobblestone_barrier", () -> {
        return new BlockItem(BLOCK_MOSSY_COBBLESTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "bricks_barrier")
    public static RegistryObject<Block> BLOCK_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.BRICKS));
    });

    @AutoRegister(name = "bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("bricks_barrier", () -> {
        return new BlockItem(BLOCK_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "terracotta_barrier")
    public static RegistryObject<Block> BLOCK_TERRACOTTA_BARRIER = ModernLifeCommon.BLOCKS.register("terracotta_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.TERRACOTTA));
    });

    @AutoRegister(name = "terracotta_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_TERRACOTTA_BARRIER = ModernLifeCommon.ITEMS.register("terracotta_barrier", () -> {
        return new BlockItem(BLOCK_TERRACOTTA_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "sandstone_barrier")
    public static RegistryObject<Block> BLOCK_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.SANDSTONE));
    });

    @AutoRegister(name = "sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("sandstone_barrier", () -> {
        return new BlockItem(BLOCK_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chiseled_sandstone_barrier")
    public static RegistryObject<Block> BLOCK_CHISELED_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("chiseled_sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHISELED_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("chiseled_sandstone_barrier", () -> {
        return new BlockItem(BLOCK_CHISELED_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "cut_sandstone_barrier")
    public static RegistryObject<Block> BLOCK_CUT_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("cut_sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CUT_SANDSTONE));
    });

    @AutoRegister(name = "cut_sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CUT_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("cut_sandstone_barrier", () -> {
        return new BlockItem(BLOCK_CUT_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "red_sandstone_barrier")
    public static RegistryObject<Block> BLOCK_RED_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("red_sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.RED_SANDSTONE));
    });

    @AutoRegister(name = "red_sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_RED_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("red_sandstone_barrier", () -> {
        return new BlockItem(BLOCK_RED_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chiseled_red_sandstone_barrier")
    public static RegistryObject<Block> BLOCK_CHISELED_RED_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("chiseled_red_sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_RED_SANDSTONE));
    });

    @AutoRegister(name = "chiseled_red_sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHISELED_RED_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("chiseled_red_sandstone_barrier", () -> {
        return new BlockItem(BLOCK_CHISELED_RED_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "cut_red_sandstone_barrier")
    public static RegistryObject<Block> BLOCK_CUT_RED_SANDSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("cut_red_sandstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CUT_RED_SANDSTONE));
    });

    @AutoRegister(name = "cut_red_sandstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CUT_RED_SANDSTONE_BARRIER = ModernLifeCommon.ITEMS.register("cut_red_sandstone_barrier", () -> {
        return new BlockItem(BLOCK_CUT_RED_SANDSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "prismarine_barrier")
    public static RegistryObject<Block> BLOCK_PRISMARINE_BARRIER = ModernLifeCommon.BLOCKS.register("prismarine_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE));
    });

    @AutoRegister(name = "prismarine_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_PRISMARINE_BARRIER = ModernLifeCommon.ITEMS.register("prismarine_barrier", () -> {
        return new BlockItem(BLOCK_PRISMARINE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "prismarine_bricks_barrier")
    public static RegistryObject<Block> BLOCK_PRISMARINE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("prismarine_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.PRISMARINE_BRICKS));
    });

    @AutoRegister(name = "prismarine_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_PRISMARINE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("prismarine_bricks_barrier", () -> {
        return new BlockItem(BLOCK_PRISMARINE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "dark_prismarine_barrier")
    public static RegistryObject<Block> BLOCK_DARK_PRISMARINE_BARRIER = ModernLifeCommon.BLOCKS.register("dark_prismarine_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.DARK_PRISMARINE));
    });

    @AutoRegister(name = "dark_prismarine_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_DARK_PRISMARINE_BARRIER = ModernLifeCommon.ITEMS.register("dark_prismarine_barrier", () -> {
        return new BlockItem(BLOCK_DARK_PRISMARINE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "blackstone_barrier")
    public static RegistryObject<Block> BLOCK_BLACKSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("blackstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.BLACKSTONE));
    });

    @AutoRegister(name = "blackstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_BLACKSTONE_BARRIER = ModernLifeCommon.ITEMS.register("blackstone_barrier", () -> {
        return new BlockItem(BLOCK_BLACKSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "polished_blackstone_barrier")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("polished_blackstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "polished_blackstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_BARRIER = ModernLifeCommon.ITEMS.register("polished_blackstone_barrier", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "polished_blackstone_bricks_barrier")
    public static RegistryObject<Block> BLOCK_POLISHED_BLACKSTONE_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("polished_blackstone_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.POLISHED_BLACKSTONE_BRICKS));
    });

    @AutoRegister(name = "polished_blackstone_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_POLISHED_BLACKSTONE_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("polished_blackstone_bricks_barrier", () -> {
        return new BlockItem(BLOCK_POLISHED_BLACKSTONE_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_barrier")
    public static RegistryObject<Block> BLOCK_CHISELED_POLISHED_BLACKSTONE_BARRIER = ModernLifeCommon.BLOCKS.register("chiseled_polished_blackstone_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_POLISHED_BLACKSTONE));
    });

    @AutoRegister(name = "chiseled_polished_blackstone_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHISELED_POLISHED_BLACKSTONE_BARRIER = ModernLifeCommon.ITEMS.register("chiseled_polished_blackstone_barrier", () -> {
        return new BlockItem(BLOCK_CHISELED_POLISHED_BLACKSTONE_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "netherrack_barrier")
    public static RegistryObject<Block> BLOCK_NETHERRACK_BARRIER = ModernLifeCommon.BLOCKS.register("netherrack_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.NETHERRACK));
    });

    @AutoRegister(name = "netherrack_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_NETHERRACK_BARRIER = ModernLifeCommon.ITEMS.register("netherrack_barrier", () -> {
        return new BlockItem(BLOCK_NETHERRACK_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "nether_bricks_barrier")
    public static RegistryObject<Block> BLOCK_NETHER_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("nether_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.NETHER_BRICKS));
    });

    @AutoRegister(name = "nether_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_NETHER_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("nether_bricks_barrier", () -> {
        return new BlockItem(BLOCK_NETHER_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chiseled_nether_bricks_barrier")
    public static RegistryObject<Block> BLOCK_CHISELED_NETHER_BRICKS_BARRIER = ModernLifeCommon.BLOCKS.register("chiseled_nether_bricks_barrier", () -> {
        return new BarrierBlock(BlockBehaviour.Properties.copy(Blocks.CHISELED_NETHER_BRICKS));
    });

    @AutoRegister(name = "chiseled_nether_bricks_barrier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHISELED_NETHER_BRICKS_BARRIER = ModernLifeCommon.ITEMS.register("chiseled_nether_bricks_barrier", () -> {
        return new BlockItem(BLOCK_CHISELED_NETHER_BRICKS_BARRIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "chainsaw", itemClass = ChainsawItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_CHAINSAW = ModernLifeCommon.ITEMS.register("chainsaw", () -> {
        return new ChainsawItem(new Tier() { // from class: com.dairymoose.modernlife.core.CustomBlocks.1
            C01141() {
            }

            public int getUses() {
                return 0;
            }

            public float getSpeed() {
                return 4.0f;
            }

            public float getAttackDamageBonus() {
                return 0.0f;
            }

            public int getLevel() {
                return 1;
            }

            public int getEnchantmentValue() {
                return 0;
            }

            public Ingredient getRepairIngredient() {
                return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_CHAINSAW.get()});
            }
        }, 0.0f, 0.0f, new Item.Properties().defaultDurability(1000).tab(CreativeModeTab.TAB_TOOLS));
    });
    public static RegistryObject<SoundEvent> SOUND_BOAT_MOTOR = ModernLifeCommon.SOUND_EVENTS.register("boat_motor", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "boat_motor"));
    });
    public static RegistryObject<SoundEvent> SOUND_CHAINSAW_RUNNING = ModernLifeCommon.SOUND_EVENTS.register("chainsaw_running", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "chainsaw_running"));
    });
    public static RegistryObject<SoundEvent> SOUND_CHAINSAW_IDLE = ModernLifeCommon.SOUND_EVENTS.register("chainsaw_idle", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "chainsaw_idle"));
    });
    public static RegistryObject<SoundEvent> SOUND_CHAINSAW_START = ModernLifeCommon.SOUND_EVENTS.register("chainsaw_start", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "chainsaw_start"));
    });
    public static RegistryObject<SoundEvent> SOUND_CHAINSAW_STOP = ModernLifeCommon.SOUND_EVENTS.register("chainsaw_stop", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "chainsaw_stop"));
    });
    public static RegistryObject<SoundEvent> SOUND_TOILET_FLUSH = ModernLifeCommon.SOUND_EVENTS.register("toilet_flush", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "toilet_flush"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUN_FIRE = ModernLifeCommon.SOUND_EVENTS.register("gun_fire", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "gun_fire"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUN_RELOAD = ModernLifeCommon.SOUND_EVENTS.register("gun_reload", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "gun_reload"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_E = ModernLifeCommon.SOUND_EVENTS.register("note_e_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_e_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_A = ModernLifeCommon.SOUND_EVENTS.register("note_a_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_a_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_D = ModernLifeCommon.SOUND_EVENTS.register("note_d_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_d_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_G = ModernLifeCommon.SOUND_EVENTS.register("note_g_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_g_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_B = ModernLifeCommon.SOUND_EVENTS.register("note_b_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_b_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_GUITAR_HI_E = ModernLifeCommon.SOUND_EVENTS.register("note_hi_e_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "note_hi_e_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_E = ModernLifeCommon.SOUND_EVENTS.register("dist_e_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_e_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_A = ModernLifeCommon.SOUND_EVENTS.register("dist_a_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_a_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_D = ModernLifeCommon.SOUND_EVENTS.register("dist_d_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_d_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_G = ModernLifeCommon.SOUND_EVENTS.register("dist_g_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_g_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_B = ModernLifeCommon.SOUND_EVENTS.register("dist_b_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_b_plus_one_octave"));
    });
    public static RegistryObject<SoundEvent> SOUND_DIST_GUITAR_HI_E = ModernLifeCommon.SOUND_EVENTS.register("dist_hi_e_plus_one_octave", () -> {
        return new SoundEvent(new ResourceLocation("modernlife", "dist_hi_e_plus_one_octave"));
    });

    @AutoRegister(name = "handgun", customInstance = true)
    public static RegistryObject<Item> ITEM_HANDGUN = ModernLifeCommon.ITEMS.register("handgun", () -> {
        return new HandgunItem(new Tier() { // from class: com.dairymoose.modernlife.core.CustomBlocks.2
            C01152() {
            }

            public int getUses() {
                return 0;
            }

            public float getSpeed() {
                return 1.0f;
            }

            public float getAttackDamageBonus() {
                return 0.0f;
            }

            public int getLevel() {
                return 1;
            }

            public int getEnchantmentValue() {
                return 0;
            }

            public Ingredient getRepairIngredient() {
                return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_HANDGUN.get()});
            }
        }, 0.0f, 20.0f, new Item.Properties().defaultDurability(1000).tab(CreativeModeTab.TAB_TOOLS));
    });

    @AutoRegister(name = "bullet")
    public static RegistryObject<Item> ITEM_BULLET = ModernLifeCommon.ITEMS.register("bullet", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).stacksTo(64));
    });

    @AutoRegister(name = "bullet_strip")
    public static RegistryObject<Item> ITEM_BULLET_STRIP = ModernLifeCommon.ITEMS.register("bullet_strip", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).stacksTo(64));
    });

    @AutoRegister(name = "gun_magazine")
    public static RegistryObject<Item> ITEM_MAGAZINE = ModernLifeCommon.ITEMS.register("gun_magazine", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).durability(18).setNoRepair());
    });

    @AutoRegister(name = "extended_gun_magazine")
    public static RegistryObject<Item> ITEM_EXTENDED_MAGAZINE = ModernLifeCommon.ITEMS.register("extended_gun_magazine", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).durability(36).setNoRepair());
    });

    @AutoRegister(name = "acacia_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_ACACIA_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("acacia_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "acacia_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_ACACIA_ROUND_TABLE = ModernLifeCommon.ITEMS.register("acacia_round_table", () -> {
        return new BlockItem(BLOCK_ACACIA_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "birch_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_BIRCH_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("birch_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "birch_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_BIRCH_ROUND_TABLE = ModernLifeCommon.ITEMS.register("birch_round_table", () -> {
        return new BlockItem(BLOCK_BIRCH_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "crimson_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_CRIMSON_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("crimson_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "crimson_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CRIMSON_ROUND_TABLE = ModernLifeCommon.ITEMS.register("crimson_round_table", () -> {
        return new BlockItem(BLOCK_CRIMSON_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "dark_oak_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_DARK_OAK_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("dark_oak_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "dark_oak_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_DARK_OAK_ROUND_TABLE = ModernLifeCommon.ITEMS.register("dark_oak_round_table", () -> {
        return new BlockItem(BLOCK_DARK_OAK_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "jungle_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_JUNGLE_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("jungle_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "jungle_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_JUNGLE_ROUND_TABLE = ModernLifeCommon.ITEMS.register("jungle_round_table", () -> {
        return new BlockItem(BLOCK_JUNGLE_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "oak_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_OAK_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("oak_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "oak_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_OAK_ROUND_TABLE = ModernLifeCommon.ITEMS.register("oak_round_table", () -> {
        return new BlockItem(BLOCK_OAK_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "spruce_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_SPRUCE_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("spruce_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "spruce_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_SPRUCE_ROUND_TABLE = ModernLifeCommon.ITEMS.register("spruce_round_table", () -> {
        return new BlockItem(BLOCK_SPRUCE_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "warped_round_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_WARPED_ROUND_TABLE = ModernLifeCommon.BLOCKS.register("warped_round_table", () -> {
        return new RoundTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "warped_round_table", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_WARPED_ROUND_TABLE = ModernLifeCommon.ITEMS.register("warped_round_table", () -> {
        return new BlockItem(BLOCK_WARPED_ROUND_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "vinyl_siding")
    public static RegistryObject<Block> BLOCK_VINYL_SIDING = ModernLifeCommon.BLOCKS.register("vinyl_siding", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "vinyl_siding", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_VINYL_SIDING = ModernLifeCommon.ITEMS.register("vinyl_siding", () -> {
        return new BlockItem(BLOCK_VINYL_SIDING.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "red_vinyl_siding")
    public static RegistryObject<Block> BLOCK_RED_VINYL_SIDING = ModernLifeCommon.BLOCKS.register("red_vinyl_siding", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "red_vinyl_siding", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_RED_VINYL_SIDING = ModernLifeCommon.ITEMS.register("red_vinyl_siding", () -> {
        return new BlockItem(BLOCK_RED_VINYL_SIDING.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "green_vinyl_siding")
    public static RegistryObject<Block> BLOCK_GREEN_VINYL_SIDING = ModernLifeCommon.BLOCKS.register("green_vinyl_siding", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "green_vinyl_siding", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_GREEN_VINYL_SIDING = ModernLifeCommon.ITEMS.register("green_vinyl_siding", () -> {
        return new BlockItem(BLOCK_GREEN_VINYL_SIDING.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "blue_vinyl_siding")
    public static RegistryObject<Block> BLOCK_BLUE_VINYL_SIDING = ModernLifeCommon.BLOCKS.register("blue_vinyl_siding", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "blue_vinyl_siding", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BLUE_VINYL_SIDING = ModernLifeCommon.ITEMS.register("blue_vinyl_siding", () -> {
        return new BlockItem(BLOCK_BLUE_VINYL_SIDING.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "gray_vinyl_siding")
    public static RegistryObject<Block> BLOCK_GRAY_VINYL_SIDING = ModernLifeCommon.BLOCKS.register("gray_vinyl_siding", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "gray_vinyl_siding", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_GRAY_VINYL_SIDING = ModernLifeCommon.ITEMS.register("gray_vinyl_siding", () -> {
        return new BlockItem(BLOCK_GRAY_VINYL_SIDING.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "four_panel_window", blockClass = AlmostFullBlock.class, material = "GLASS", soundType = "GLASS", strength = HandgunItem.handgunZoomFactor, renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_FOUR_PANEL_WINDOW = ModernLifeCommon.BLOCKS.register("four_panel_window", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "four_panel_window", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_FOUR_PANEL_WINDOW = ModernLifeCommon.ITEMS.register("four_panel_window", () -> {
        return new BlockItem(BLOCK_FOUR_PANEL_WINDOW.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "six_panel_window", blockClass = AlmostFullBlock.class, material = "GLASS", soundType = "GLASS", strength = HandgunItem.handgunZoomFactor, renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_SIX_PANEL_WINDOW = ModernLifeCommon.BLOCKS.register("six_panel_window", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "six_panel_window", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_SIX_PANEL_WINDOW = ModernLifeCommon.ITEMS.register("six_panel_window", () -> {
        return new BlockItem(BLOCK_SIX_PANEL_WINDOW.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "hedge", blockClass = AlmostFullBlock.class, material = "GRASS", soundType = "GRASS", strength = HandgunItem.handgunZoomFactor, renderType = "cutout")
    public static RegistryObject<Block> BLOCK_HEDGE = ModernLifeCommon.BLOCKS.register("hedge", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.OAK_LEAVES));
    });

    @AutoRegister(name = "hedge", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_HEDGE = ModernLifeCommon.ITEMS.register("hedge", () -> {
        return new BlockItem(BLOCK_HEDGE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "white_ceramic_tile", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_WHITE_CERAMIC_TILE = ModernLifeCommon.BLOCKS.register("white_ceramic_tile", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "white_ceramic_tile", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_WHITE_CERAMIC_TILE = ModernLifeCommon.ITEMS.register("white_ceramic_tile", () -> {
        return new BlockItem(BLOCK_WHITE_CERAMIC_TILE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "beige_ceramic_tile", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BEIGE_CERAMIC_TILE = ModernLifeCommon.BLOCKS.register("beige_ceramic_tile", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "beige_ceramic_tile", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BEIGE_CERAMIC_TILE = ModernLifeCommon.ITEMS.register("beige_ceramic_tile", () -> {
        return new BlockItem(BLOCK_BEIGE_CERAMIC_TILE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "brown_ceramic_tile", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BROWN_CERAMIC_TILE = ModernLifeCommon.BLOCKS.register("brown_ceramic_tile", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "brown_ceramic_tile", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BROWN_CERAMIC_TILE = ModernLifeCommon.ITEMS.register("brown_ceramic_tile", () -> {
        return new BlockItem(BLOCK_BROWN_CERAMIC_TILE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "rocky_ceramic_tile", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_ROCKY_CERAMIC_TILE = ModernLifeCommon.BLOCKS.register("rocky_ceramic_tile", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "rocky_ceramic_tile", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_ROCKY_CERAMIC_TILE = ModernLifeCommon.ITEMS.register("rocky_ceramic_tile", () -> {
        return new BlockItem(BLOCK_ROCKY_CERAMIC_TILE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "black_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BLACK_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("black_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "black_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BLACK_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("black_painted_drywall", () -> {
        return new BlockItem(BLOCK_BLACK_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "blue_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BLUE_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("blue_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "blue_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BLUE_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("blue_painted_drywall", () -> {
        return new BlockItem(BLOCK_BLUE_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "brown_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BROWN_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("brown_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "brown_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BROWN_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("brown_painted_drywall", () -> {
        return new BlockItem(BLOCK_BROWN_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "cyan_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_CYAN_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("cyan_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "cyan_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_CYAN_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("cyan_painted_drywall", () -> {
        return new BlockItem(BLOCK_CYAN_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "gray_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_GRAY_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("gray_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "gray_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_GRAY_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("gray_painted_drywall", () -> {
        return new BlockItem(BLOCK_GRAY_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "green_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_GREEN_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("green_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "green_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_GREEN_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("green_painted_drywall", () -> {
        return new BlockItem(BLOCK_GREEN_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "light_blue_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_LIGHT_BLUE_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("light_blue_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "light_blue_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_LIGHT_BLUE_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("light_blue_painted_drywall", () -> {
        return new BlockItem(BLOCK_LIGHT_BLUE_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "light_gray_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_LIGHT_GRAY_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("light_gray_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "light_gray_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_LIGHT_GRAY_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("light_gray_painted_drywall", () -> {
        return new BlockItem(BLOCK_LIGHT_GRAY_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "lime_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_LIME_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("lime_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "lime_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_LIME_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("lime_painted_drywall", () -> {
        return new BlockItem(BLOCK_LIME_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "magenta_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_MAGENTA_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("magenta_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "magenta_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_MAGENTA_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("magenta_painted_drywall", () -> {
        return new BlockItem(BLOCK_MAGENTA_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "orange_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_ORANGE_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("orange_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "orange_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_ORANGE_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("orange_painted_drywall", () -> {
        return new BlockItem(BLOCK_ORANGE_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "pink_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_PINK_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("pink_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "pink_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_PINK_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("pink_painted_drywall", () -> {
        return new BlockItem(BLOCK_PINK_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "purple_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_PURPLE_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("purple_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "purple_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_PURPLE_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("purple_painted_drywall", () -> {
        return new BlockItem(BLOCK_PURPLE_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "red_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_RED_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("red_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "red_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_RED_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("red_painted_drywall", () -> {
        return new BlockItem(BLOCK_RED_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "white_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_WHITE_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("white_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "white_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_WHITE_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("white_painted_drywall", () -> {
        return new BlockItem(BLOCK_WHITE_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "yellow_painted_drywall", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_YELLOW_PAINTED_DRYWALL = ModernLifeCommon.BLOCKS.register("yellow_painted_drywall", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "yellow_painted_drywall", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_YELLOW_PAINTED_DRYWALL = ModernLifeCommon.ITEMS.register("yellow_painted_drywall", () -> {
        return new BlockItem(BLOCK_YELLOW_PAINTED_DRYWALL.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "bathroom_ceramic_tile", blockClass = Block.class, material = "CLAY", soundType = "GRAVEL", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_BATHROOM_CERAMIC_TILE = ModernLifeCommon.BLOCKS.register("bathroom_ceramic_tile", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "bathroom_ceramic_tile", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BATHROOM_CERAMIC_TILE = ModernLifeCommon.ITEMS.register("bathroom_ceramic_tile", () -> {
        return new BlockItem(BLOCK_BATHROOM_CERAMIC_TILE.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "acacia_deck")
    public static RegistryObject<Block> BLOCK_ACACIA_DECK = ModernLifeCommon.BLOCKS.register("acacia_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_ACACIA_DECK = ModernLifeCommon.ITEMS.register("acacia_deck", () -> {
        return new BlockItem(BLOCK_ACACIA_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "birch_deck")
    public static RegistryObject<Block> BLOCK_BIRCH_DECK = ModernLifeCommon.BLOCKS.register("birch_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_BIRCH_DECK = ModernLifeCommon.ITEMS.register("birch_deck", () -> {
        return new BlockItem(BLOCK_BIRCH_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "crimson_deck")
    public static RegistryObject<Block> BLOCK_CRIMSON_DECK = ModernLifeCommon.BLOCKS.register("crimson_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_CRIMSON_DECK = ModernLifeCommon.ITEMS.register("crimson_deck", () -> {
        return new BlockItem(BLOCK_CRIMSON_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "dark_oak_deck")
    public static RegistryObject<Block> BLOCK_DARK_OAK_DECK = ModernLifeCommon.BLOCKS.register("dark_oak_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_DARK_OAK_DECK = ModernLifeCommon.ITEMS.register("dark_oak_deck", () -> {
        return new BlockItem(BLOCK_DARK_OAK_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "jungle_deck")
    public static RegistryObject<Block> BLOCK_JUNGLE_DECK = ModernLifeCommon.BLOCKS.register("jungle_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_JUNGLE_DECK = ModernLifeCommon.ITEMS.register("jungle_deck", () -> {
        return new BlockItem(BLOCK_JUNGLE_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "oak_deck")
    public static RegistryObject<Block> BLOCK_OAK_DECK = ModernLifeCommon.BLOCKS.register("oak_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_OAK_DECK = ModernLifeCommon.ITEMS.register("oak_deck", () -> {
        return new BlockItem(BLOCK_OAK_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "spruce_deck")
    public static RegistryObject<Block> BLOCK_SPRUCE_DECK = ModernLifeCommon.BLOCKS.register("spruce_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_SPRUCE_DECK = ModernLifeCommon.ITEMS.register("spruce_deck", () -> {
        return new BlockItem(BLOCK_SPRUCE_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "warped_deck")
    public static RegistryObject<Block> BLOCK_WARPED_DECK = ModernLifeCommon.BLOCKS.register("warped_deck", () -> {
        return new DeckBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_deck", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_WARPED_DECK = ModernLifeCommon.ITEMS.register("warped_deck", () -> {
        return new BlockItem(BLOCK_WARPED_DECK.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "guitar", itemClass = GuitarItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_GUITAR = ModernLifeCommon.ITEMS.register("guitar", () -> {
        return new GuitarItem(new Tier() { // from class: com.dairymoose.modernlife.core.CustomBlocks.3
            C01163() {
            }

            public int getUses() {
                return 0;
            }

            public float getSpeed() {
                return 1.2f;
            }

            public float getAttackDamageBonus() {
                return 0.0f;
            }

            public int getLevel() {
                return 0;
            }

            public int getEnchantmentValue() {
                return 0;
            }

            public Ingredient getRepairIngredient() {
                return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_GUITAR.get()});
            }
        }, 0.0f, 0.0f, new Item.Properties().defaultDurability(50).tab(CreativeModeTab.TAB_TOOLS));
    });

    @AutoRegister(name = "guitar_amplifier", blockClass = AlmostFullBlock.class, material = "WOOD", soundType = "WOOD", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_GUITAR_AMPLIFIER = ModernLifeCommon.BLOCKS.register("guitar_amplifier", () -> {
        return new GuitarAmplifierBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "guitar_amplifier", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_GUITAR_AMPLIFIER = ModernLifeCommon.ITEMS.register("guitar_amplifier", () -> {
        return new BlockItem(BLOCK_GUITAR_AMPLIFIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "seed_spreader", blockClass = SeedSpreaderBlock.class, material = "METAL", soundType = "METAL", strength = 2.5f, renderType = "cutout")
    public static RegistryObject<Block> BLOCK_SEED_SPREADER = ModernLifeCommon.BLOCKS.register("seed_spreader", () -> {
        return new SeedSpreaderBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "seed_spreader", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_SEED_SPREADER = ModernLifeCommon.ITEMS.register("seed_spreader", () -> {
        return new BlockItem(BLOCK_SEED_SPREADER.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "power_transmitter", blockClass = PowerTransmitterBlock.class, material = "METAL", soundType = "METAL", strength = 2.5f, renderType = "cutout")
    public static RegistryObject<Block> BLOCK_POWER_TRANSMITTER = ModernLifeCommon.BLOCKS.register("power_transmitter", () -> {
        return new PowerTransmitterBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "power_transmitter", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_POWER_TRANSMITTER = ModernLifeCommon.ITEMS.register("power_transmitter", () -> {
        return new BlockItem(BLOCK_POWER_TRANSMITTER.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "power_receiver", blockClass = PowerReceiverBlock.class, material = "METAL", soundType = "METAL", strength = 2.5f, renderType = "cutout")
    public static RegistryObject<Block> BLOCK_POWER_RECEIVER = ModernLifeCommon.BLOCKS.register("power_receiver", () -> {
        return new PowerReceiverBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "power_receiver", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_POWER_RECEIVER = ModernLifeCommon.ITEMS.register("power_receiver", () -> {
        return new BlockItem(BLOCK_POWER_RECEIVER.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "microwave", blockClass = AlmostFullBlock.class, material = "METAL", soundType = "METAL", strength = 2.5f, renderType = "translucent")
    public static RegistryObject<Block> BLOCK_MICROWAVE = ModernLifeCommon.BLOCKS.register("microwave", () -> {
        return new MicrowaveBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "microwave", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_MICROWAVE = ModernLifeCommon.ITEMS.register("microwave", () -> {
        return new BlockItem(BLOCK_MICROWAVE.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "stove", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_STOVE = ModernLifeCommon.BLOCKS.register("stove", () -> {
        return new StoveBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "stove")
    public static RegistryObject<Item> ITEM_STOVE = ModernLifeCommon.ITEMS.register("stove", () -> {
        return new BlockItem(BLOCK_STOVE.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "photon", blockClass = PhotonBlock.class, material = "AIR", soundType = "WOOL", strength = 0.1f)
    public static RegistryObject<Block> BLOCK_PHOTON = ModernLifeCommon.BLOCKS.register("photon", () -> {
        return new PhotonBlock(BlockBehaviour.Properties.copy(Blocks.AIR));
    });

    @AutoRegister(name = "flashlight", itemClass = FlashlightItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_FLASHLIGHT = ModernLifeCommon.ITEMS.register("flashlight", () -> {
        return new FlashlightItem(new Tier() { // from class: com.dairymoose.modernlife.core.CustomBlocks.4
            C01174() {
            }

            public int getUses() {
                return 0;
            }

            public float getSpeed() {
                return 1.0f;
            }

            public float getAttackDamageBonus() {
                return 0.0f;
            }

            public int getLevel() {
                return 1;
            }

            public int getEnchantmentValue() {
                return 0;
            }

            public Ingredient getRepairIngredient() {
                return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_BATTERY.get()});
            }
        }, 0.0f, 0.0f, new Item.Properties().defaultDurability(ModernLifeCommon.FLASHLIGHT_DURATION_MINUTES * 60 * 20).tab(CreativeModeTab.TAB_TOOLS));
    });

    @AutoRegister(name = "winch", material = "METAL", soundType = "METAL", strength = HandgunItem.handgunZoomFactor, renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_WINCH = ModernLifeCommon.BLOCKS.register("winch", () -> {
        return new WinchBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "winch", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_WINCH = ModernLifeCommon.ITEMS.register("winch", () -> {
        return new BlockItem(BLOCK_WINCH.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "winch_anchor", material = "METAL", soundType = "METAL", strength = 0.5f)
    public static RegistryObject<Block> BLOCK_WINCH_ANCHOR = ModernLifeCommon.BLOCKS.register("winch_anchor", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "winch_anchor", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_WINCH_ANCHOR = ModernLifeCommon.ITEMS.register("winch_anchor", () -> {
        return new BlockItem(BLOCK_WINCH_ANCHOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "turntable", blockClass = TurntableBlock.class, material = "WOOD", soundType = "WOOD", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_TURNTABLE = ModernLifeCommon.BLOCKS.register("turntable", () -> {
        return new TurntableBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "turntable", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_TURNTABLE = ModernLifeCommon.ITEMS.register("turntable", () -> {
        return new BlockItem(BLOCK_TURNTABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "speedometer", itemClass = SpeedometerItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_SPEEDOMETER = ModernLifeCommon.ITEMS.register("speedometer", () -> {
        return new SpeedometerItem(new Item.Properties().defaultDurability(50).tab(CreativeModeTab.TAB_TOOLS));
    });

    @AutoRegister(name = "trash_can", blockClass = TrashCanBlock.class, material = "METAL", soundType = "METAL", strength = 2.0f)
    public static RegistryObject<Block> BLOCK_TRASH_CAN = ModernLifeCommon.BLOCKS.register("trash_can", () -> {
        return new TrashCanBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "trash_can", tab = "TAB_REDSTONE")
    public static RegistryObject<Item> ITEM_TRASH_CAN = ModernLifeCommon.ITEMS.register("trash_can", () -> {
        return new BlockItem(BLOCK_TRASH_CAN.get(), new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "paved_road", blockClass = PavedRoadBlock.class, material = "STONE", soundType = "STONE", strength = HandgunItem.handgunZoomFactor)
    public static RegistryObject<Block> BLOCK_PAVED_ROAD = ModernLifeCommon.BLOCKS.register("paved_road", () -> {
        return new PavedRoadBlock(BlockBehaviour.Properties.copy(Blocks.BLACK_CONCRETE));
    });

    @AutoRegister(name = "paved_road", tab = "TAB_BUILDING_BLOCKS")
    public static RegistryObject<Item> ITEM_PAVED_ROAD = ModernLifeCommon.ITEMS.register("paved_road", () -> {
        return new BlockItem(BLOCK_PAVED_ROAD.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS));
    });

    @AutoRegister(name = "battery", itemClass = Item.class, customInstance = true)
    public static RegistryObject<Item> ITEM_BATTERY = ModernLifeCommon.ITEMS.register("battery", () -> {
        return new BatteryItem(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).stacksTo(64));
    });

    @AutoRegister(name = "bicycle_item", itemClass = BicycleItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_BICYCLE = ModernLifeCommon.ITEMS.register("bicycle_item", () -> {
        return new BicycleItem(new Item.Properties().tab(CreativeModeTab.TAB_TRANSPORTATION).defaultDurability(100));
    });

    @AutoRegister(name = "motorboat_item", itemClass = MotorboatItem.class, customInstance = true)
    public static RegistryObject<Item> ITEM_MOTORBOAT = ModernLifeCommon.ITEMS.register("motorboat_item", () -> {
        return new MotorboatItem(new Item.Properties().tab(CreativeModeTab.TAB_TRANSPORTATION).defaultDurability(100));
    });

    @AutoRegister(name = "tire", itemClass = Item.class, customInstance = true)
    public static RegistryObject<Item> ITEM_TIRE = ModernLifeCommon.ITEMS.register("tire", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS).stacksTo(4));
    });

    @AutoRegister(name = "chess_board")
    public static RegistryObject<Block> BLOCK_CHESS_BOARD = ModernLifeCommon.BLOCKS.register("chess_board", () -> {
        return new ChessBoardBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "chess_board", tab = "TAB_MISC")
    public static RegistryObject<Item> ITEM_CHESS_BOARD = ModernLifeCommon.ITEMS.register("chess_board", () -> {
        return new BlockItem(BLOCK_CHESS_BOARD.get(), new Item.Properties().tab(CreativeModeTab.TAB_BUILDING_BLOCKS).stacksTo(1));
    });

    @AutoRegister(name = "coffee_mug")
    public static RegistryObject<Block> BLOCK_COFFEE_MUG = ModernLifeCommon.BLOCKS.register("coffee_mug", () -> {
        return new CoffeeMugBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "coffee_mug", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_COFFEE_MUG = ModernLifeCommon.ITEMS.register("coffee_mug", () -> {
        return new BlockItem(BLOCK_COFFEE_MUG.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "floor_mat")
    public static RegistryObject<Block> BLOCK_FLOOR_MAT = ModernLifeCommon.BLOCKS.register("floor_mat", () -> {
        return new FloorMatBlock(BlockBehaviour.Properties.copy(Blocks.BAMBOO));
    });

    @AutoRegister(name = "floor_mat", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_FLOOR_MAT = ModernLifeCommon.ITEMS.register("floor_mat", () -> {
        return new BlockItem(BLOCK_FLOOR_MAT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "inset_light", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_INSET_LIGHT = ModernLifeCommon.BLOCKS.register("inset_light", () -> {
        return new Block(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE).lightLevel(blockstate -> {
            return 15;
        }));
    });

    @AutoRegister(name = "inset_light", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_INSET_LIGHT = ModernLifeCommon.ITEMS.register("inset_light", () -> {
        return new BlockItem(BLOCK_INSET_LIGHT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_mini_stool")
    public static RegistryObject<Block> BLOCK_ACACIA_MINI_STOOL = ModernLifeCommon.BLOCKS.register("acacia_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_WOOD));
    });

    @AutoRegister(name = "acacia_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ACACIA_MINI_STOOL = ModernLifeCommon.ITEMS.register("acacia_mini_stool", () -> {
        return new BlockItem(BLOCK_ACACIA_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_mini_stool")
    public static RegistryObject<Block> BLOCK_BIRCH_MINI_STOOL = ModernLifeCommon.BLOCKS.register("birch_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_WOOD));
    });

    @AutoRegister(name = "birch_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BIRCH_MINI_STOOL = ModernLifeCommon.ITEMS.register("birch_mini_stool", () -> {
        return new BlockItem(BLOCK_BIRCH_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_mini_stool")
    public static RegistryObject<Block> BLOCK_CRIMSON_MINI_STOOL = ModernLifeCommon.BLOCKS.register("crimson_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CRIMSON_MINI_STOOL = ModernLifeCommon.ITEMS.register("crimson_mini_stool", () -> {
        return new BlockItem(BLOCK_CRIMSON_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_mini_stool")
    public static RegistryObject<Block> BLOCK_DARK_OAK_MINI_STOOL = ModernLifeCommon.BLOCKS.register("dark_oak_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_WOOD));
    });

    @AutoRegister(name = "dark_oak_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DARK_OAK_MINI_STOOL = ModernLifeCommon.ITEMS.register("dark_oak_mini_stool", () -> {
        return new BlockItem(BLOCK_DARK_OAK_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_mini_stool")
    public static RegistryObject<Block> BLOCK_JUNGLE_MINI_STOOL = ModernLifeCommon.BLOCKS.register("jungle_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_WOOD));
    });

    @AutoRegister(name = "jungle_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_JUNGLE_MINI_STOOL = ModernLifeCommon.ITEMS.register("jungle_mini_stool", () -> {
        return new BlockItem(BLOCK_JUNGLE_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_mini_stool")
    public static RegistryObject<Block> BLOCK_OAK_MINI_STOOL = ModernLifeCommon.BLOCKS.register("oak_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.OAK_WOOD));
    });

    @AutoRegister(name = "oak_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OAK_MINI_STOOL = ModernLifeCommon.ITEMS.register("oak_mini_stool", () -> {
        return new BlockItem(BLOCK_OAK_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_mini_stool")
    public static RegistryObject<Block> BLOCK_SPRUCE_MINI_STOOL = ModernLifeCommon.BLOCKS.register("spruce_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_WOOD));
    });

    @AutoRegister(name = "spruce_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SPRUCE_MINI_STOOL = ModernLifeCommon.ITEMS.register("spruce_mini_stool", () -> {
        return new BlockItem(BLOCK_SPRUCE_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_mini_stool")
    public static RegistryObject<Block> BLOCK_WARPED_MINI_STOOL = ModernLifeCommon.BLOCKS.register("warped_mini_stool", () -> {
        return new MiniStoolBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_mini_stool", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WARPED_MINI_STOOL = ModernLifeCommon.ITEMS.register("warped_mini_stool", () -> {
        return new BlockItem(BLOCK_WARPED_MINI_STOOL.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_chair")
    public static RegistryObject<Block> BLOCK_ACACIA_CHAIR = ModernLifeCommon.BLOCKS.register("acacia_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_WOOD));
    });

    @AutoRegister(name = "acacia_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ACACIA_CHAIR = ModernLifeCommon.ITEMS.register("acacia_chair", () -> {
        return new BlockItem(BLOCK_ACACIA_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_chair")
    public static RegistryObject<Block> BLOCK_BIRCH_CHAIR = ModernLifeCommon.BLOCKS.register("birch_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_WOOD));
    });

    @AutoRegister(name = "birch_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BIRCH_CHAIR = ModernLifeCommon.ITEMS.register("birch_chair", () -> {
        return new BlockItem(BLOCK_BIRCH_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_chair")
    public static RegistryObject<Block> BLOCK_CRIMSON_CHAIR = ModernLifeCommon.BLOCKS.register("crimson_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_STEM));
    });

    @AutoRegister(name = "crimson_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CRIMSON_CHAIR = ModernLifeCommon.ITEMS.register("crimson_chair", () -> {
        return new BlockItem(BLOCK_CRIMSON_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_chair")
    public static RegistryObject<Block> BLOCK_DARK_OAK_CHAIR = ModernLifeCommon.BLOCKS.register("dark_oak_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_WOOD));
    });

    @AutoRegister(name = "dark_oak_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DARK_OAK_CHAIR = ModernLifeCommon.ITEMS.register("dark_oak_chair", () -> {
        return new BlockItem(BLOCK_DARK_OAK_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_chair")
    public static RegistryObject<Block> BLOCK_JUNGLE_CHAIR = ModernLifeCommon.BLOCKS.register("jungle_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_WOOD));
    });

    @AutoRegister(name = "jungle_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_JUNGLE_CHAIR = ModernLifeCommon.ITEMS.register("jungle_chair", () -> {
        return new BlockItem(BLOCK_JUNGLE_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_chair")
    public static RegistryObject<Block> BLOCK_OAK_CHAIR = ModernLifeCommon.BLOCKS.register("oak_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.OAK_WOOD));
    });

    @AutoRegister(name = "oak_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OAK_CHAIR = ModernLifeCommon.ITEMS.register("oak_chair", () -> {
        return new BlockItem(BLOCK_OAK_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_chair")
    public static RegistryObject<Block> BLOCK_SPRUCE_CHAIR = ModernLifeCommon.BLOCKS.register("spruce_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_WOOD));
    });

    @AutoRegister(name = "spruce_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SPRUCE_CHAIR = ModernLifeCommon.ITEMS.register("spruce_chair", () -> {
        return new BlockItem(BLOCK_SPRUCE_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_chair")
    public static RegistryObject<Block> BLOCK_WARPED_CHAIR = ModernLifeCommon.BLOCKS.register("warped_chair", () -> {
        return new ChairBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_STEM));
    });

    @AutoRegister(name = "warped_chair", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WARPED_CHAIR = ModernLifeCommon.ITEMS.register("warped_chair", () -> {
        return new BlockItem(BLOCK_WARPED_CHAIR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "music_stand")
    public static RegistryObject<Block> BLOCK_MUSIC_STAND = ModernLifeCommon.BLOCKS.register("music_stand", () -> {
        return new MusicStandBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "music_stand", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_MUSIC_STAND = ModernLifeCommon.ITEMS.register("music_stand", () -> {
        return new BlockItem(BLOCK_MUSIC_STAND.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "lantern_post")
    public static RegistryObject<Block> BLOCK_LANTERN_POST = ModernLifeCommon.BLOCKS.register("lantern_post", () -> {
        return new LanternPostBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "lantern_post", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_LANTERN_POST = ModernLifeCommon.ITEMS.register("lantern_post", () -> {
        return new BlockItem(BLOCK_LANTERN_POST.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "street_light")
    public static RegistryObject<Block> BLOCK_STREET_LIGHT = ModernLifeCommon.BLOCKS.register("street_light", () -> {
        return new StreetLightBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "street_light", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_STREET_LIGHT = ModernLifeCommon.ITEMS.register("street_light", () -> {
        return new BlockItem(BLOCK_STREET_LIGHT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "old_tv")
    public static RegistryObject<Block> BLOCK_OLD_TV = ModernLifeCommon.BLOCKS.register("old_tv", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "old_tv", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OLD_TV = ModernLifeCommon.ITEMS.register("old_tv", () -> {
        return new BlockItem(BLOCK_OLD_TV.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "flatscreen_tv")
    public static RegistryObject<Block> BLOCK_FLATSCREEN_TV = ModernLifeCommon.BLOCKS.register("flatscreen_tv", () -> {
        return new FlatScreenTvBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "flatscreen_tv", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_FLATSCREEN_TV = ModernLifeCommon.ITEMS.register("flatscreen_tv", () -> {
        return new BlockItem(BLOCK_FLATSCREEN_TV.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "monitor")
    public static RegistryObject<Block> BLOCK_MONITOR = ModernLifeCommon.BLOCKS.register("monitor", () -> {
        return new MonitorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "monitor", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_MONITOR = ModernLifeCommon.ITEMS.register("monitor", () -> {
        return new BlockItem(BLOCK_MONITOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dual_monitor")
    public static RegistryObject<Block> BLOCK_DUAL_MONITOR = ModernLifeCommon.BLOCKS.register("dual_monitor", () -> {
        return new DualMonitorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "dual_monitor", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DUAL_MONITOR = ModernLifeCommon.ITEMS.register("dual_monitor", () -> {
        return new BlockItem(BLOCK_DUAL_MONITOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_small_table")
    public static RegistryObject<Block> BLOCK_ACACIA_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("acacia_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ACACIA_SMALL_TABLE = ModernLifeCommon.ITEMS.register("acacia_small_table", () -> {
        return new BlockItem(BLOCK_ACACIA_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_small_table")
    public static RegistryObject<Block> BLOCK_BIRCH_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("birch_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BIRCH_SMALL_TABLE = ModernLifeCommon.ITEMS.register("birch_small_table", () -> {
        return new BlockItem(BLOCK_BIRCH_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_small_table")
    public static RegistryObject<Block> BLOCK_CRIMSON_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("crimson_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CRIMSON_SMALL_TABLE = ModernLifeCommon.ITEMS.register("crimson_small_table", () -> {
        return new BlockItem(BLOCK_CRIMSON_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_small_table")
    public static RegistryObject<Block> BLOCK_DARK_OAK_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("dark_oak_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DARK_OAK_SMALL_TABLE = ModernLifeCommon.ITEMS.register("dark_oak_small_table", () -> {
        return new BlockItem(BLOCK_DARK_OAK_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_small_table")
    public static RegistryObject<Block> BLOCK_JUNGLE_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("jungle_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_JUNGLE_SMALL_TABLE = ModernLifeCommon.ITEMS.register("jungle_small_table", () -> {
        return new BlockItem(BLOCK_JUNGLE_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_small_table")
    public static RegistryObject<Block> BLOCK_OAK_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("oak_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OAK_SMALL_TABLE = ModernLifeCommon.ITEMS.register("oak_small_table", () -> {
        return new BlockItem(BLOCK_OAK_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_small_table")
    public static RegistryObject<Block> BLOCK_SPRUCE_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("spruce_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SPRUCE_SMALL_TABLE = ModernLifeCommon.ITEMS.register("spruce_small_table", () -> {
        return new BlockItem(BLOCK_SPRUCE_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_small_table")
    public static RegistryObject<Block> BLOCK_WARPED_SMALL_TABLE = ModernLifeCommon.BLOCKS.register("warped_small_table", () -> {
        return new SmallTableBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_small_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WARPED_SMALL_TABLE = ModernLifeCommon.ITEMS.register("warped_small_table", () -> {
        return new BlockItem(BLOCK_WARPED_SMALL_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_coffee_table")
    public static RegistryObject<Block> BLOCK_ACACIA_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("acacia_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_ACACIA_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("acacia_coffee_table", () -> {
        return new BlockItem(BLOCK_ACACIA_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_coffee_table")
    public static RegistryObject<Block> BLOCK_BIRCH_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("birch_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_BIRCH_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("birch_coffee_table", () -> {
        return new BlockItem(BLOCK_BIRCH_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_coffee_table")
    public static RegistryObject<Block> BLOCK_CRIMSON_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("crimson_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_CRIMSON_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("crimson_coffee_table", () -> {
        return new BlockItem(BLOCK_CRIMSON_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_coffee_table")
    public static RegistryObject<Block> BLOCK_DARK_OAK_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("dark_oak_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DARK_OAK_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("dark_oak_coffee_table", () -> {
        return new BlockItem(BLOCK_DARK_OAK_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_coffee_table")
    public static RegistryObject<Block> BLOCK_JUNGLE_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("jungle_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_JUNGLE_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("jungle_coffee_table", () -> {
        return new BlockItem(BLOCK_JUNGLE_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_coffee_table")
    public static RegistryObject<Block> BLOCK_OAK_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("oak_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_OAK_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("oak_coffee_table", () -> {
        return new BlockItem(BLOCK_OAK_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_coffee_table")
    public static RegistryObject<Block> BLOCK_SPRUCE_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("spruce_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_SPRUCE_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("spruce_coffee_table", () -> {
        return new BlockItem(BLOCK_SPRUCE_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_coffee_table")
    public static RegistryObject<Block> BLOCK_WARPED_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("warped_coffee_table", () -> {
        return new CoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_WARPED_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("warped_coffee_table", () -> {
        return new BlockItem(BLOCK_WARPED_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_acacia_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_ACACIA_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_acacia_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_acacia_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_ACACIA_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_acacia_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_ACACIA_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_birch_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_BIRCH_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_birch_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_birch_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_BIRCH_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_birch_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_BIRCH_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_crimson_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_CRIMSON_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_crimson_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_crimson_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_CRIMSON_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_crimson_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_CRIMSON_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_dark_oak_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_DARK_OAK_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_dark_oak_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_dark_oak_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_DARK_OAK_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_dark_oak_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_DARK_OAK_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_jungle_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_JUNGLE_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_jungle_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_jungle_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_JUNGLE_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_jungle_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_JUNGLE_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_oak_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_OAK_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_oak_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_oak_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_OAK_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_oak_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_OAK_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_spruce_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_SPRUCE_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_spruce_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_spruce_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_SPRUCE_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_spruce_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_SPRUCE_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_warped_coffee_table", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_WARPED_COFFEE_TABLE = ModernLifeCommon.BLOCKS.register("glass_warped_coffee_table", () -> {
        return new GlassCoffeeTableBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_warped_coffee_table", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_WARPED_COFFEE_TABLE = ModernLifeCommon.ITEMS.register("glass_warped_coffee_table", () -> {
        return new BlockItem(BLOCK_GLASS_WARPED_COFFEE_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "glass_slab", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_SLAB = ModernLifeCommon.BLOCKS.register("glass_slab", () -> {
        return new SlabBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_slab", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_GLASS_SLAB = ModernLifeCommon.ITEMS.register("glass_slab", () -> {
        return new BlockItem(BLOCK_GLASS_SLAB.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "printer")
    public static RegistryObject<Block> BLOCK_PRINTER = ModernLifeCommon.BLOCKS.register("printer", () -> {
        return new PrinterBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "printer", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_PRINTER = ModernLifeCommon.ITEMS.register("printer", () -> {
        return new BlockItem(BLOCK_PRINTER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "photocopier")
    public static RegistryObject<Block> BLOCK_PHOTOCOPIER = ModernLifeCommon.BLOCKS.register("photocopier", () -> {
        return new PhotocopierBlock(BlockBehaviour.Properties.copy(Blocks.IRON_BLOCK));
    });

    @AutoRegister(name = "photocopier", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_PHOTOCOPIER = ModernLifeCommon.ITEMS.register("photocopier", () -> {
        return new BlockItem(BLOCK_PHOTOCOPIER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "camera", customInstance = true)
    public static RegistryObject<Item> ITEM_CAMERA = ModernLifeCommon.ITEMS.register("camera", () -> {
        return new CameraItem(new Item.Properties().tab(CreativeModeTab.TAB_TOOLS).durability(30));
    });

    @AutoRegister(name = "glass_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.GLASS));
    });

    @AutoRegister(name = "glass_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_acacia_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_ACACIA_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_acacia_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_TRAPDOOR));
    });

    @AutoRegister(name = "glass_acacia_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_ACACIA_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_acacia_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_ACACIA_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_birch_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_BIRCH_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_birch_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_TRAPDOOR));
    });

    @AutoRegister(name = "glass_birch_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_BIRCH_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_birch_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_BIRCH_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_crimson_trapdoor", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_GLASS_CRIMSON_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_crimson_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_TRAPDOOR));
    });

    @AutoRegister(name = "glass_crimson_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_CRIMSON_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_crimson_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_CRIMSON_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_dark_oak_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_DARK_OAK_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_dark_oak_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_TRAPDOOR));
    });

    @AutoRegister(name = "glass_dark_oak_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_DARK_OAK_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_dark_oak_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_DARK_OAK_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_iron_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_IRON_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_iron_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.IRON_TRAPDOOR));
    });

    @AutoRegister(name = "glass_iron_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_IRON_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_iron_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_IRON_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_jungle_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_JUNGLE_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_jungle_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_TRAPDOOR));
    });

    @AutoRegister(name = "glass_jungle_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_JUNGLE_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_jungle_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_JUNGLE_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_oak_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_OAK_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_oak_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.OAK_TRAPDOOR));
    });

    @AutoRegister(name = "glass_oak_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_OAK_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_oak_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_OAK_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_spruce_trapdoor", renderType = "cutoutMipped")
    public static RegistryObject<Block> BLOCK_GLASS_SPRUCE_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_spruce_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_TRAPDOOR));
    });

    @AutoRegister(name = "glass_spruce_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_SPRUCE_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_spruce_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_SPRUCE_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "glass_warped_trapdoor", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_GLASS_WARPED_TRAPDOOR = ModernLifeCommon.BLOCKS.register("glass_warped_trapdoor", () -> {
        return new TrapDoorBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_TRAPDOOR));
    });

    @AutoRegister(name = "glass_warped_trapdoor")
    public static RegistryObject<Item> ITEM_GLASS_WARPED_TRAPDOOR = ModernLifeCommon.ITEMS.register("glass_warped_trapdoor", () -> {
        return new BlockItem(BLOCK_GLASS_WARPED_TRAPDOOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_REDSTONE));
    });

    @AutoRegister(name = "washing_machine", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_WASHING_MACHINE = ModernLifeCommon.BLOCKS.register("washing_machine", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "washing_machine")
    public static RegistryObject<Item> ITEM_WASHING_MACHINE = ModernLifeCommon.ITEMS.register("washing_machine", () -> {
        return new BlockItem(BLOCK_WASHING_MACHINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dryer", renderType = "translucent")
    public static RegistryObject<Block> BLOCK_DRYER = ModernLifeCommon.BLOCKS.register("dryer", () -> {
        return new AlmostFullBlock(BlockBehaviour.Properties.copy(Blocks.COBBLESTONE));
    });

    @AutoRegister(name = "dryer")
    public static RegistryObject<Item> ITEM_DRYER = ModernLifeCommon.ITEMS.register("dryer", () -> {
        return new BlockItem(BLOCK_DRYER.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "refrigerator")
    public static RegistryObject<Block> BLOCK_REFRIGERATOR = ModernLifeCommon.BLOCKS.register("refrigerator", () -> {
        return new RefrigeratorBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "refrigerator", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_REFRIGERATOR = ModernLifeCommon.ITEMS.register("refrigerator", () -> {
        return new BlockItem(BLOCK_REFRIGERATOR.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "deluxe_bed")
    public static RegistryObject<Block> BLOCK_DELUXE_BED = ModernLifeCommon.BLOCKS.register("deluxe_bed", () -> {
        return new DeluxeBedBlock(BlockBehaviour.Properties.copy(Blocks.GRAY_WOOL));
    });

    @AutoRegister(name = "deluxe_bed", tab = "TAB_DECORATIONS")
    public static RegistryObject<Item> ITEM_DELUXE_BED = ModernLifeCommon.ITEMS.register("deluxe_bed", () -> {
        return new BlockItem(BLOCK_DELUXE_BED.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "acacia_picnic_table")
    public static RegistryObject<Block> BLOCK_ACACIA_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("acacia_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.ACACIA_PLANKS));
    });

    @AutoRegister(name = "acacia_picnic_table")
    public static RegistryObject<Item> ITEM_ACACIA_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("acacia_picnic_table", () -> {
        return new BlockItem(BLOCK_ACACIA_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "birch_picnic_table")
    public static RegistryObject<Block> BLOCK_BIRCH_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("birch_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.BIRCH_PLANKS));
    });

    @AutoRegister(name = "birch_picnic_table")
    public static RegistryObject<Item> ITEM_BIRCH_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("birch_picnic_table", () -> {
        return new BlockItem(BLOCK_BIRCH_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "crimson_picnic_table")
    public static RegistryObject<Block> BLOCK_CRIMSON_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("crimson_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.CRIMSON_PLANKS));
    });

    @AutoRegister(name = "crimson_picnic_table")
    public static RegistryObject<Item> ITEM_CRIMSON_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("crimson_picnic_table", () -> {
        return new BlockItem(BLOCK_CRIMSON_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "dark_oak_picnic_table")
    public static RegistryObject<Block> BLOCK_DARK_OAK_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("dark_oak_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.DARK_OAK_PLANKS));
    });

    @AutoRegister(name = "dark_oak_picnic_table")
    public static RegistryObject<Item> ITEM_DARK_OAK_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("dark_oak_picnic_table", () -> {
        return new BlockItem(BLOCK_DARK_OAK_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "jungle_picnic_table")
    public static RegistryObject<Block> BLOCK_JUNGLE_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("jungle_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.JUNGLE_PLANKS));
    });

    @AutoRegister(name = "jungle_picnic_table")
    public static RegistryObject<Item> ITEM_JUNGLE_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("jungle_picnic_table", () -> {
        return new BlockItem(BLOCK_JUNGLE_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "oak_picnic_table")
    public static RegistryObject<Block> BLOCK_OAK_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("oak_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.OAK_PLANKS));
    });

    @AutoRegister(name = "oak_picnic_table")
    public static RegistryObject<Item> ITEM_OAK_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("oak_picnic_table", () -> {
        return new BlockItem(BLOCK_OAK_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "spruce_picnic_table")
    public static RegistryObject<Block> BLOCK_SPRUCE_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("spruce_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.SPRUCE_PLANKS));
    });

    @AutoRegister(name = "spruce_picnic_table")
    public static RegistryObject<Item> ITEM_SPRUCE_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("spruce_picnic_table", () -> {
        return new BlockItem(BLOCK_SPRUCE_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "warped_picnic_table")
    public static RegistryObject<Block> BLOCK_WARPED_PICNIC_TABLE = ModernLifeCommon.BLOCKS.register("warped_picnic_table", () -> {
        return new PicnicTableBlock(BlockBehaviour.Properties.copy(Blocks.WARPED_PLANKS));
    });

    @AutoRegister(name = "warped_picnic_table")
    public static RegistryObject<Item> ITEM_WARPED_PICNIC_TABLE = ModernLifeCommon.ITEMS.register("warped_picnic_table", () -> {
        return new BlockItem(BLOCK_WARPED_PICNIC_TABLE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "bathtub", renderType = "cutout")
    public static RegistryObject<Block> BLOCK_BATHTUB = ModernLifeCommon.BLOCKS.register("bathtub", () -> {
        return new BathtubBlock(BlockBehaviour.Properties.copy(Blocks.CLAY));
    });

    @AutoRegister(name = "bathtub")
    public static RegistryObject<Item> ITEM_BATHTUB = ModernLifeCommon.ITEMS.register("bathtub", () -> {
        return new BlockItem(BLOCK_BATHTUB.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "gas_can")
    public static RegistryObject<Item> ITEM_GAS_CAN = ModernLifeCommon.ITEMS.register("gas_can", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC).durability(MotorboatEntity.FULL_FUEL_LEVEL));
    });

    @AutoRegister(name = "rook")
    public static RegistryObject<Item> ITEM_CHESS_ROOK = ModernLifeCommon.ITEMS.register("rook", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "bishop")
    public static RegistryObject<Item> ITEM_CHESS_BISHOP = ModernLifeCommon.ITEMS.register("bishop", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "pawn")
    public static RegistryObject<Item> ITEM_CHESS_PAWN = ModernLifeCommon.ITEMS.register("pawn", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "knight")
    public static RegistryObject<Item> ITEM_CHESS_KNIGHT = ModernLifeCommon.ITEMS.register("knight", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "king")
    public static RegistryObject<Item> ITEM_CHESS_KING = ModernLifeCommon.ITEMS.register("king", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "queen")
    public static RegistryObject<Item> ITEM_CHESS_QUEEN = ModernLifeCommon.ITEMS.register("queen", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "rook_w")
    public static RegistryObject<Item> ITEM_CHESS_ROOK_W = ModernLifeCommon.ITEMS.register("rook_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "bishop_w")
    public static RegistryObject<Item> ITEM_CHESS_BISHOP_W = ModernLifeCommon.ITEMS.register("bishop_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "pawn_w")
    public static RegistryObject<Item> ITEM_CHESS_PAWN_W = ModernLifeCommon.ITEMS.register("pawn_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "knight_w")
    public static RegistryObject<Item> ITEM_CHESS_KNIGHT_W = ModernLifeCommon.ITEMS.register("knight_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "king_w")
    public static RegistryObject<Item> ITEM_CHESS_KING_W = ModernLifeCommon.ITEMS.register("king_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "queen_w")
    public static RegistryObject<Item> ITEM_CHESS_QUEEN_W = ModernLifeCommon.ITEMS.register("queen_w", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MISC));
    });

    @AutoRegister(name = "memory_card")
    public static RegistryObject<Item> ITEM_MEMORY_CARD = ModernLifeCommon.ITEMS.register("memory_card", () -> {
        return new Item(new Item.Properties().tab(CreativeModeTab.TAB_MATERIALS));
    });

    @AutoRegister(name = "road_marker")
    public static RegistryObject<Item> ITEM_ROAD_MARKER = ModernLifeCommon.ITEMS.register("road_marker", () -> {
        return new RoadMarkerItem(new Item.Properties().tab(CreativeModeTab.TAB_TRANSPORTATION).defaultDurability(1000));
    });

    @AutoRegister(name = "road_marker_white")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE = ModernLifeCommon.BLOCKS.register("road_marker_white", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE = ModernLifeCommon.ITEMS.register("road_marker_white", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_white_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_white_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_yellow")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_YELLOW = ModernLifeCommon.BLOCKS.register("road_marker_yellow", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.YELLOW_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_yellow")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_YELLOW = ModernLifeCommon.ITEMS.register("road_marker_yellow", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_YELLOW.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_yellow_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_YELLOW_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_yellow_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.YELLOW_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_yellow_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_YELLOW_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_yellow_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_YELLOW_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_double_yellow")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_DOUBLE_YELLOW = ModernLifeCommon.BLOCKS.register("road_marker_double_yellow", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.YELLOW_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_double_yellow")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_DOUBLE_YELLOW = ModernLifeCommon.ITEMS.register("road_marker_double_yellow", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_DOUBLE_YELLOW.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_double_yellow_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_DOUBLE_YELLOW_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_double_yellow_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.YELLOW_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_double_yellow_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_DOUBLE_YELLOW_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_double_yellow_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_DOUBLE_YELLOW_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_shoulder_left")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_SHOULDER_LEFT = ModernLifeCommon.BLOCKS.register("road_marker_white_shoulder_left", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_shoulder_left")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_SHOULDER_LEFT = ModernLifeCommon.ITEMS.register("road_marker_white_shoulder_left", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_SHOULDER_LEFT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_shoulder_left_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_SHOULDER_LEFT_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_white_shoulder_left_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_shoulder_left_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_SHOULDER_LEFT_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_white_shoulder_left_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_SHOULDER_LEFT_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_shoulder_right")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_SHOULDER_RIGHT = ModernLifeCommon.BLOCKS.register("road_marker_white_shoulder_right", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_shoulder_right")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_SHOULDER_RIGHT = ModernLifeCommon.ITEMS.register("road_marker_white_shoulder_right", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_SHOULDER_RIGHT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_shoulder_right_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_SHOULDER_RIGHT_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_white_shoulder_right_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_shoulder_right_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_SHOULDER_RIGHT_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_white_shoulder_right_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_SHOULDER_RIGHT_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_corner_left")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_CORNER_LEFT = ModernLifeCommon.BLOCKS.register("road_marker_white_corner_left", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_corner_left")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_CORNER_LEFT = ModernLifeCommon.ITEMS.register("road_marker_white_corner_left", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_CORNER_LEFT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_corner_left_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_CORNER_LEFT_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_white_corner_left_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_corner_left_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_CORNER_LEFT_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_white_corner_left_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_CORNER_LEFT_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_corner_right")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_CORNER_RIGHT = ModernLifeCommon.BLOCKS.register("road_marker_white_corner_right", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_corner_right")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_CORNER_RIGHT = ModernLifeCommon.ITEMS.register("road_marker_white_corner_right", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_CORNER_RIGHT.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });

    @AutoRegister(name = "road_marker_white_corner_right_incline")
    public static RegistryObject<Block> BLOCK_ROAD_MARKER_WHITE_CORNER_RIGHT_INCLINE = ModernLifeCommon.BLOCKS.register("road_marker_white_corner_right_incline", () -> {
        return new RoadMarkerBlock(BlockBehaviour.Properties.copy(Blocks.WHITE_CONCRETE).noCollission());
    });

    @AutoRegister(name = "road_marker_white_corner_right_incline")
    public static RegistryObject<Item> ITEM_ROAD_MARKER_WHITE_CORNER_RIGHT_INCLINE = ModernLifeCommon.ITEMS.register("road_marker_white_corner_right_incline", () -> {
        return new BlockItem(BLOCK_ROAD_MARKER_WHITE_CORNER_RIGHT_INCLINE.get(), new Item.Properties().tab(CreativeModeTab.TAB_DECORATIONS));
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_RADIATOR = ModernLifeCommon.BLOCK_ENTITIES.register("steam_radiator", () -> {
        return RadiatorBlockEntity.RADIATOR;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_CANVAS = ModernLifeCommon.BLOCK_ENTITIES.register("canvas", () -> {
        return CanvasBlockEntity.CANVAS;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_EASEL = ModernLifeCommon.BLOCK_ENTITIES.register("easel", () -> {
        return EaselBlockEntity.EASEL;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_EXTRACTOR = ModernLifeCommon.BLOCK_ENTITIES.register("extractor", () -> {
        return ExtractorBlockEntity.EXTRACTOR;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_SEED_SPREADER = ModernLifeCommon.BLOCK_ENTITIES.register("seed_spreader", () -> {
        return SeedSpreaderBlockEntity.SEED_SPREADER;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_POWER_TRANSMITTER = ModernLifeCommon.BLOCK_ENTITIES.register("power_transmitter", () -> {
        return PowerTransmitterBlockEntity.POWER_TRANSMITTER;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_POWER_RECEIVER = ModernLifeCommon.BLOCK_ENTITIES.register("power_receiver", () -> {
        return PowerReceiverBlockEntity.POWER_RECEIVER;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_PHOTON = ModernLifeCommon.BLOCK_ENTITIES.register("photon", () -> {
        return PhotonBlockEntity.PHOTON;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_NIGHT_STAND = ModernLifeCommon.BLOCK_ENTITIES.register("night_stand", () -> {
        return NightStandBlockEntity.NIGHT_STAND;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_TRASH_CAN = ModernLifeCommon.BLOCK_ENTITIES.register("trash_can", () -> {
        return TrashCanBlockEntity.TRASH_CAN;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_SHOWER_HEAD = ModernLifeCommon.BLOCK_ENTITIES.register("shower_head", () -> {
        return ShowerHeadBlockEntity.SHOWER_HEAD;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_CHESS_BOARD = ModernLifeCommon.BLOCK_ENTITIES.register("chess_board", () -> {
        return ChessBoardBlockEntity.CHESS_BOARD;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_MICROWAVE = ModernLifeCommon.BLOCK_ENTITIES.register("microwave", () -> {
        return MicrowaveBlockEntity.MICROWAVE;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_STOVE = ModernLifeCommon.BLOCK_ENTITIES.register("stove", () -> {
        return StoveBlockEntity.STOVE;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_PRINTER = ModernLifeCommon.BLOCK_ENTITIES.register("printer", () -> {
        return PrinterBlockEntity.PRINTER;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_PHOTOCOPIER = ModernLifeCommon.BLOCK_ENTITIES.register("photocopier", () -> {
        return PhotocopierBlockEntity.PHOTOCOPIER;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_REFRIGERATOR = ModernLifeCommon.BLOCK_ENTITIES.register("refrigerator", () -> {
        return RefrigeratorBlockEntity.REFRIGERATOR;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_TOILET = ModernLifeCommon.BLOCK_ENTITIES.register("toilet", () -> {
        return ToiletBlockEntity.TOILET;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_MIRROR = ModernLifeCommon.BLOCK_ENTITIES.register("mirror", () -> {
        return MirrorBlockEntity.MIRROR;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_CCTV_CAMERA = ModernLifeCommon.BLOCK_ENTITIES.register("cctv_camera", () -> {
        return CCTVCameraBlockEntity.CCTV_CAMERA;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_ALARM_CLOCK = ModernLifeCommon.BLOCK_ENTITIES.register("alarm_clock", () -> {
        return AlarmClockBlockEntity.ALARM_CLOCK;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_WALL_SHELF = ModernLifeCommon.BLOCK_ENTITIES.register("wall_shelf", () -> {
        return WallShelfBlockEntity.WALL_SHELF;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_DOUBLE_WALL_SHELF = ModernLifeCommon.BLOCK_ENTITIES.register("double_wall_shelf", () -> {
        return WallShelfBlockEntity.DOUBLE_WALL_SHELF;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_WINCH = ModernLifeCommon.BLOCK_ENTITIES.register("winch", () -> {
        return WinchBlockEntity.WINCH;
    });
    public static RegistryObject<BlockEntityType<?>> BLOCKENTITY_MODERN_BOOKSHELF = ModernLifeCommon.BLOCK_ENTITIES.register("modern_bookshelf", () -> {
        return ModernBookshelfBlockEntity.MODERN_BOOKSHELF;
    });
    public static RegistryObject<EntityType<?>> ENTITY_THROWN_SEED = ModernLifeCommon.ENTITIES.register("thrown_seed", () -> {
        return ThrownSeedEntity.THROWN_SEED_ENTITY;
    });
    public static RegistryObject<EntityType<?>> ENTITY_BICYCLE = ModernLifeCommon.ENTITIES.register("bicycle", () -> {
        return BicycleEntity.BICYCLE_ENTITY;
    });
    public static RegistryObject<EntityType<?>> ENTITY_MOTORBOAT = ModernLifeCommon.ENTITIES.register("motorboat", () -> {
        return MotorboatEntity.MOTORBOAT_ENTITY;
    });
    public static RegistryObject<EntityType<?>> ENTITY_DUMMY = ModernLifeCommon.ENTITIES.register("dummy", () -> {
        return DummyEntity.DUMMY_ENTITY;
    });
    public static RegistryObject<MenuType<?>> ENTITY_TRASH_CAN = ModernLifeCommon.CONTAINERS.register("trash_can", () -> {
        return TrashCanContainer.TRASH_CAN_CONTAINER_TYPE;
    });

    /* renamed from: com.dairymoose.modernlife.core.CustomBlocks$1 */
    /* loaded from: outputsrg.jar:com/dairymoose/modernlife/core/CustomBlocks$1.class */
    public class C01141 implements Tier {
        C01141() {
        }

        public int getUses() {
            return 0;
        }

        public float getSpeed() {
            return 4.0f;
        }

        public float getAttackDamageBonus() {
            return 0.0f;
        }

        public int getLevel() {
            return 1;
        }

        public int getEnchantmentValue() {
            return 0;
        }

        public Ingredient getRepairIngredient() {
            return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_CHAINSAW.get()});
        }
    }

    /* renamed from: com.dairymoose.modernlife.core.CustomBlocks$2 */
    /* loaded from: outputsrg.jar:com/dairymoose/modernlife/core/CustomBlocks$2.class */
    public class C01152 implements Tier {
        C01152() {
        }

        public int getUses() {
            return 0;
        }

        public float getSpeed() {
            return 1.0f;
        }

        public float getAttackDamageBonus() {
            return 0.0f;
        }

        public int getLevel() {
            return 1;
        }

        public int getEnchantmentValue() {
            return 0;
        }

        public Ingredient getRepairIngredient() {
            return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_HANDGUN.get()});
        }
    }

    /* renamed from: com.dairymoose.modernlife.core.CustomBlocks$3 */
    /* loaded from: outputsrg.jar:com/dairymoose/modernlife/core/CustomBlocks$3.class */
    public class C01163 implements Tier {
        C01163() {
        }

        public int getUses() {
            return 0;
        }

        public float getSpeed() {
            return 1.2f;
        }

        public float getAttackDamageBonus() {
            return 0.0f;
        }

        public int getLevel() {
            return 0;
        }

        public int getEnchantmentValue() {
            return 0;
        }

        public Ingredient getRepairIngredient() {
            return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_GUITAR.get()});
        }
    }

    /* renamed from: com.dairymoose.modernlife.core.CustomBlocks$4 */
    /* loaded from: outputsrg.jar:com/dairymoose/modernlife/core/CustomBlocks$4.class */
    public class C01174 implements Tier {
        C01174() {
        }

        public int getUses() {
            return 0;
        }

        public float getSpeed() {
            return 1.0f;
        }

        public float getAttackDamageBonus() {
            return 0.0f;
        }

        public int getLevel() {
            return 1;
        }

        public int getEnchantmentValue() {
            return 0;
        }

        public Ingredient getRepairIngredient() {
            return Ingredient.of(new ItemLike[]{(ItemLike) CustomBlocks.ITEM_BATTERY.get()});
        }
    }
}
