recipes or some

public class CauldronRecipeSerializer implements RecipeSerializer<CauldronRecipe> {
    public CauldronRecipeSerializer () {}

    public MapCodec<CauldronRecipe> codec () {
        return new MapCodec<CauldronRecipe>() {
            public <T> KeyCompressor<T> compressor (DynamicOps<T> ops) {
                return new KeyCompressor<T>(ops, this.keys());
            }

            public <T> DataResult<CauldronRecipe> decode (DynamicOps<T> ops, MapLike<T> input) {
                try {
                    List<T> inputs = ops.getStream(input.get("inputs")).result().getOrThrow().collect(Collectors.asList());
                    List<ItemStack> items = List.<ItemStack>of();
                    for (T t : inputs) {
                        MapLike<T> map = ops.getMap(t).result().getOrThrow();
                        items.add(new ItemStack(Registries.ITEMS.get(Identifier.of(ops.getString(map.get("item")).result().getOrThrow())), ops.getNumberValue(map.get("count")).result().getOrDefault(Integer.valueOf(1)).intValue()));
                    }
                    MapLike<T> map = ops.getMap(input.get("result")).result().getOrThrow();
                    ItemStack output = new ItemStack(Registries.ITEMS.get(Identifier.of(ops.getString(map.get("item")).result().getOrThrow())), ops.getNumberValue(map.get("count")).result().getOrDefault(Integer.valueOf(1)).intValue());
                    boolean stoked = ops.getBooleanValue(input.get("stoked")).result().getOrDefault(Boolean.FALSE).booleanValue();
                    return DataResult.<CauldronRecipe>success(new CauldronRecipe(inputs, output, stoked));
                } catch (NullPointerException npe) {
                    return DataResult.<CauldronRecipe>error("Key could not be resolved");
                }
            }

            public <T> RecordBuilder<T> encode (CauldronRecipe input, DynamicOps<T> ops, RecordBuilder<T> prefix) {
                List<T> inputs = List.<T>of();
                for (ItemStack item : input.getInputs())
                    inputs.add(ops.createMap(Map.<T, T>of(ops.createString("item"), ops.createString(Registries.ITEMS.getId(item).toString()), ops.createString("count"), ops.createNumeric(Integer.valueOf(item.getCount())))));
                prefix.add("inputs", ops.createList(inputs.stream()));
                prefix.add("output", ops.createMap(Map.<T, T>of(ops.createString("item"), ops.createString(Registries.ITEMS.getId(input.getOutput()).toString()), ops.createString("count"), ops.createNumeric(Integer.valueOf(input.getOutput().getCount())))));
                prefix.add("stoked", ops.createBoolean(input.isStoked()));
                return prefix;
            }

            public <T> Stream<T> keys (DynamicOps<T> ops) {
                return List.<T>of(ops.createString("inputs"), ops.createString("output"), ops.createString("stoked")).stream();
            }
        }
    }

    public PacketCodec<RegistryByteBuf, CauldronRecipe> packetCodec () {
        return new PacketCodec<RegistryByteBuf, CauldronRecipe>() {
            public void encode (RegistryByteBuf buf, CauldronRecipe input) {
                buf.writeInt(input.getInputs().size());
                for (ItemStack i : input.getInputs()) {
                    buf.writeString(buf.getRegistryManager().get(Registries.ITEMS.getKey()).getId(i.getItem()).toString());
                    buf.writeInt(i.getCount());
                }
                buf.writeString(buf.getRegistryManager().get(Registries.ITEMS.getKey()).getId(input.getOutput().getItem()).toString());
                buf.writeInt(input.getOutput().getCount());
                buf.writeBoolean(input.isStoked());
            }

            public void encode (RegistryByteBuf buf, CauldronRecipe input) {
                int length = buf.readInt();
                List<ItemStack> inputs = List.<ItemStack>of();
                for (int i = 0; i <= length; i++) {
                    inputs.add(new ItemStack(buf.getRegistryManager().get(Registries.ITEMS.getKey()).get(Identifier.of(buf.readString())), buf.readInt()));
                }
                ItemStack output = new ItemStack(buf.getRegistryManager().get(Registries.ITEMS.getKey()).get(Identifier.of(buf.readString())), buf.readInt());
                boolean stoked = buf.readBoolean();
                return new CauldronRecipe(inputs, output, stoked);
            }
        }
    }
}