diff --git a/.gitignore b/.gitignore index 1cdc9f7..ec10551 100644 --- a/.gitignore +++ b/.gitignore @@ -1,9 +1,3 @@ target/ -pom.xml.tag -pom.xml.releaseBackup -pom.xml.versionsBackup -pom.xml.next -release.properties -dependency-reduced-pom.xml -buildNumber.properties -.mvn/timing.properties +.idea/ +*.iml diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..8dd4dd4 --- /dev/null +++ b/pom.xml @@ -0,0 +1,47 @@ + + + 4.0.0 + + com.alttd + AltitudeAPI + 0.0.2 + + UTF-8 + + + + + com.destroystokyo.paper + paper-api + 1.14.1-R0.1-SNAPSHOT + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 1.8 + 1.8 + + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.1.0 + + + org.apache.maven.plugins + maven-source-plugin + 3.1.0 + + + + + + \ No newline at end of file diff --git a/src/main/java/com/alttd/altitudeapi/AltitudeAPI.java b/src/main/java/com/alttd/altitudeapi/AltitudeAPI.java new file mode 100644 index 0000000..f172b48 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/AltitudeAPI.java @@ -0,0 +1,50 @@ +package com.alttd.altitudeapi; + +import java.io.File; + +import com.alttd.altitudeapi.utils.items.ItemDb; +import org.bukkit.plugin.java.JavaPlugin; + +public class AltitudeAPI extends JavaPlugin +{ + private static AltitudeAPI instance; + + private static ItemDb itemDb; + + public void onEnable() + { + instance = this; + + saveDefaultConfig(); + + if (getConfig().getBoolean("use-items")) + { + saveResource("items.csv", true); + itemDb = new ItemDb(new File(getDataFolder(), "items.csv")); + } + } + + /** + * Returns the {@link ItemDb} loaded by this plugin. + * + * @return the {@link ItemDb} loaded by this plugin. + */ + public static ItemDb getItemDb() + { + if (itemDb == null) + { + throw new IllegalStateException("Enable the item api in the config file."); + } + return itemDb; + } + + /** + * Returns the singleton instance of this API. + * + * @return the singleton instance of this API. + */ + public static AltitudeAPI getInstance() + { + return instance; + } +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/CommandArgument.java b/src/main/java/com/alttd/altitudeapi/commands/CommandArgument.java new file mode 100644 index 0000000..3d6dfbf --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/CommandArgument.java @@ -0,0 +1,352 @@ +package com.alttd.altitudeapi.commands; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; + +import org.bukkit.command.CommandSender; + +/** + * @param the type the argument will be after being parsed. + * + * @author Michael Ziluck + */ +public class CommandArgument +{ + protected ValidCommand command; + + protected T value; + + protected String name; + + protected boolean optional; + + protected boolean variableLength; + + protected boolean allowsConsole; + + protected int ordinal; + + protected List senderValidators; + + protected List> validators; + + protected Parser parser; + + protected String permission; + + protected String[] tabOptions; + + /** + * Constructs a new argument. This will also initialize the validators list. + */ + protected CommandArgument() + { + this.senderValidators = new LinkedList<>(); + this.validators = new LinkedList<>(); + } + + /** + * Process the given argument. This will parse it into it's appropriate form, as well as validate that it is in the + * proper state. The value returned represents whether or not the process was successful. No error message is + * required beyond what was already sent within the parsers and validators. + * + * @param sender the sender of the command. + * @param label the label of the command. + * @param argument the raw string argument to be processed. + * + * @return {@code true} if the process was successful. Otherwise, returns {@code false}. + */ + protected boolean process(CommandSender sender, String[] label, String argument) + { + if (hasPermission() && !sender.hasPermission(permission)) + { + CommandLang.NO_PERMISSION.send(sender); + return false; + } + + for (SenderValidator senderValidator : senderValidators) + { + if (!senderValidator.validate(sender)) + { + return false; + } + } + + value = parser.parseArgument(sender, label, argument); + + if (value == null) + { + return false; + } + + for (Validator validator : validators) + { + if (!validator.validateArgument(sender, label, value)) + { + return false; + } + } + + return true; + } + + /** + * Retrieves all potential options a player can have when trying to tab-complete this argument. This should always + * be implemented. However, because that most likely will not happen, it defaults to the same behavior that Bukkit + * uses which is to list off the names of all visible connected players. + * + * @param sender the sender who is tab-completing. + * @param lastWord the content of the item so far. + * + * @return all argument options. + */ + protected List getRecommendations(CommandSender sender, String lastWord) + { + List recommendations = parser.getRecommendations(sender, lastWord); + if (recommendations == null) + { + recommendations = CommandHandler.defaultTabComplete(sender, lastWord); + } + return recommendations; + } + + /** + * Clears the most recent value processed by this argument. + */ + public void clearValue() + { + value = null; + } + + /** + * @return {@code true} if the argument has a required rank. Otherwise returns {@code false}. + */ + public boolean hasPermission() + { + return permission != null; + } + + /** + * The ability to use an argument might differ from the ability to use a command in general. This is the rank + * required to use this argument within a command. + * + * @return the rank required to use this argument. + */ + public String getPermission() + { + return permission; + } + + /** + * Sets the required permission for this argument. This should only be set once, and should only be changed from the + * CommandArgumentBuilder. Will throw an {@link IllegalStateException} if set a second time. + * + * @param permission the required permission. + */ + public void setPermission(String permission) + { + if (this.permission != null) + { + throw new IllegalArgumentException("Permission can only be set once."); + } + this.permission = permission; + } + + /** + * @return the parser for this argument. + */ + public Parser getParser() + { + return parser; + } + + /** + * Sets the parser for this argument. This should only be set once, and should only be changed from the + * CommandArgumentBuilder. Will throw an {@link IllegalStateException} if set a second time. + * + * @param parser the argument's parser. + */ + protected void setParser(Parser parser) + { + if (this.parser != null) + { + throw new IllegalArgumentException("Parser can only be set once."); + } + this.parser = parser; + } + + /** + * Returns a view of the validators. This view can't be changed, and will throw exceptions if it is attempted. + * + * @return the validators for this argument. + */ + public List> getValidators() + { + return Collections.unmodifiableList(validators); + } + + /** + * Adds a new validator to the argument. + * + * @param validator the new validator. + */ + public void addValidator(Validator validator) + { + this.validators.add(validator); + } + + /** + * Returns a view of the sender validators. This view can't be changed, and will throw exception if it is attempted. + * + * @return the sender validators for this argument + */ + public List getSenderValidators() + { + return Collections.unmodifiableList(senderValidators); + } + + /** + * Adds a new sender validator to the argument. + * + * @param senderValidator the new sender validator. + */ + public void addSenderValidator(SenderValidator senderValidator) + { + this.senderValidators.add(senderValidator); + } + + /** + * Gets where in the order of arguments this argument falls for a particular command. The default is -1, so if -1 is + * returned it means that this argument has not yet been assigned to a command. + * + * @return the argument ordinal. + */ + public int getOrdinal() + { + return ordinal; + } + + /** + * Sets the order that this argument falls for a particular command. This method is protected to make sure that the + * CommandHandler does not break when managing the argument system. + * + * @param ordinal the new argument ordinal. + */ + protected void setOrdinal(int ordinal) + { + this.ordinal = ordinal; + } + + /** + * @return {@code true} if this argument can't be used by console. Otherwise returns {@code false}. + */ + public boolean allowsConsole() + { + return allowsConsole; + } + + /** + * @param status {@code true} if this argument can't be used by console. + */ + public void setAllowsConsole(boolean status) + { + this.allowsConsole = status; + } + + /** + * @return {@code true} if this argument has variable length. Otherwise returns {@code false}. + */ + public boolean hasVariableLength() + { + return variableLength; + } + + /** + * @param status {@code true} if this argument has variable length. + */ + public void setVariableLength(boolean status) + { + this.variableLength = status; + } + + /** + * @return whether this argument is optional or not. + */ + public boolean isOptional() + { + return optional; + } + + /** + * @param state whether or not the argument is optional. + */ + public void setOptional(boolean state) + { + this.optional = state; + } + + /** + * @return the name of the argument + */ + public String getName() + { + return name; + } + + /** + * Sets the name for the argument. This should only be set once, and should only be changed from the + * CommandArgumentBuilder. Will throw an {@link IllegalStateException} if set a second time. + * + * @param name the name of the argument. + */ + public void setName(String name) + { + if (this.name != null) + { + throw new IllegalStateException("Name can only be set once."); + } + this.name = name; + } + + /** + * This should only be used to check if an optional argument has a value. + * + * @return {@code true} if this argument has a value. + */ + public boolean hasValue() + { + return value != null; + } + + /** + * Gets the value that was just parsed and validated. + * + * @return the value. + */ + public T getValue() + { + if (value == null) + { + throw new IllegalStateException("Argument has not been processed."); + } + return value; + } + + /** + * @return the command this argument belongs to. + */ + protected ValidCommand getCommand() + { + return command; + } + + /** + * @param command the command this argument belongs to. + */ + protected void setCommand(ValidCommand command) + { + this.command = command; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/CommandArgumentBuilder.java b/src/main/java/com/alttd/altitudeapi/commands/CommandArgumentBuilder.java new file mode 100644 index 0000000..5f35af1 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/CommandArgumentBuilder.java @@ -0,0 +1,139 @@ +package com.alttd.altitudeapi.commands; + +public class CommandArgumentBuilder +{ + + private CommandArgument argument; + + private CommandArgumentBuilder() + { + argument = new CommandArgument<>(); + } + + /** + * Sets the name for the argument. + * + * @param name the name for the argument. + * + * @return the same builder. + */ + public CommandArgumentBuilder setName(String name) + { + argument.setName(name); + return this; + } + + /** + * Sets the parser for the argument. + * + * @param parser the parser for the argument. + * + * @return the same builder. + */ + public CommandArgumentBuilder setParser(Parser parser) + { + argument.setParser(parser); + return this; + } + + /** + * Sets the required rank for the argument. + * + * @param permission the required permission for the argument. + * + * @return the same builder. + */ + public CommandArgumentBuilder setRequiredPermission(String permission) + { + argument.setPermission(permission); + return this; + } + + /** + * Adds a validator to be used by the argument. + * + * @param validator the new validator. + * + * @return the same builder. + */ + public CommandArgumentBuilder addValidator(Validator validator) + { + argument.addValidator(validator); + return this; + } + + /** + * Adds a sender validator to be used by the argument. + * + * @param senderValidator the new sender validator. + * + * @return the same builder. + */ + public CommandArgumentBuilder addSenderValidator(SenderValidator senderValidator) + { + argument.addSenderValidator(senderValidator); + return this; + } + + /** + * Marks this argument as optional. It defaults to false which is why there is no option to disable it as each + * option should only be set once. + * + * @return the same builder. + */ + public CommandArgumentBuilder setOptional() + { + argument.setOptional(true); + return this; + } + + /** + * Marks this argument as having variable length. It defaults to false which is why there is no option to disable it + * as each option should only be set to once. + * + * @return the same builder. + */ + public CommandArgumentBuilder setVariableLength() + { + argument.setVariableLength(true); + return this; + } + + /** + * Marks this argument as usable by the console. It defaults to false which is why there is no option to disable it + * as each option should only be set once. + * + * @return the same builder + */ + public CommandArgumentBuilder setAllowsConsole() + { + argument.setAllowsConsole(true); + return this; + } + + /** + * Returns the {@link CommandArgument} that has been built. Will throw an {@link IllegalStateException} if the + * parser has not been set as it is required. + * + * @return build the completed argument. + */ + public CommandArgument build() + { + if (argument.getName() == null) + { + throw new IllegalArgumentException("Argument name not set"); + } + if (argument.getParser() == null) + { + throw new IllegalStateException("Argument parser not set."); + } + + return argument; + } + + public static CommandArgumentBuilder createBuilder(Class type) + { + return new CommandArgumentBuilder(); + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/CommandHandler.java b/src/main/java/com/alttd/altitudeapi/commands/CommandHandler.java new file mode 100644 index 0000000..c1346b6 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/CommandHandler.java @@ -0,0 +1,258 @@ +package com.alttd.altitudeapi.commands; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.PluginCommand; +import org.bukkit.command.SimpleCommandMap; +import org.bukkit.command.TabCompleter; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.SimplePluginManager; +import org.bukkit.plugin.java.JavaPlugin; + +/** + * The processor that handles all {@link ValidCommand ValidCommands}. + * + * @author Michael Ziluck + */ +public class CommandHandler implements CommandExecutor, TabCompleter +{ + + private static CommandHandler instance; + + private static SimpleCommandMap commandMapInstance = getCommandMap(); + + private static Map knownCommands = getKnownCommands(); + + private List commands; + + /** + * Constructs a new CommandHandler. Will initialize the commands list. + */ + public CommandHandler() + { + this.commands = new LinkedList<>(); + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) + { + ValidCommand command = getCommand(label); + if (command != null) + { + if (sender.hasPermission(command.getPermission())) + { + command.process(sender, new String[]{ label }, args); + } + else + { + CommandLang.NO_PERMISSION.send(sender); + } + } + else + { + return false; + } + return true; + } + + @Override + public List onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) + { + ValidCommand command = getCommand(alias); + if (command != null) + { + return command.processTabComplete(sender, args); + } + + return Collections.emptyList(); + } + + /** + * Registers the command to be used with this command handler. + * + * @param command the command to register. + * @param plugin the plugin this command is owned by. + */ + public void registerCommand(ValidCommand command, JavaPlugin plugin) + { + // remove any preexisting and conflicting commands. + for (String str : checkString(knownCommands.keySet(), command)) + { + knownCommands.remove(str); + } + + // create an instance of the bukkit command and set the proper values. + PluginCommand bukkitCommand = createBukkitCommand(command.getName(), plugin); + bukkitCommand.setAliases(Arrays.asList(command.getAliases())); + bukkitCommand.setDescription(command.getDescription()); + bukkitCommand.setExecutor(this); + bukkitCommand.setTabCompleter(this); + + // register the command with bukkit + commandMapInstance.register(plugin.getDescription().getName(), bukkitCommand); + + commands.add(command); + } + + /** + * Gets the custom command of the given name. This can be either the command's name or one of it's aliases. Will + * return null if no match was found, which should never happen assuming the command registration went properly. + * + * @param label the label of the command. + * + * @return the command, if one exists. + */ + public ValidCommand getCommand(String label) + { + for (ValidCommand command : commands) + { + if (command.matches(label)) + { + return command; + } + } + return null; + } + + /** + * Gets all list of all commands that have a name that conflicts with the given valid command. This ensures that the + * commands registered in our system will always supersede any other plugin's commands. + * + * @param strings the names of all existing commands. + * @param command the command to check. + * + * @return all conflicting preexisting commands. + */ + private List checkString(Collection strings, ValidCommand command) + { + List aliases = new ArrayList<>(Arrays.asList(command.getAliases())); + aliases.add(command.getName()); + aliases.retainAll(strings); + return aliases; + } + + private PluginCommand createBukkitCommand(String name, JavaPlugin plugin) + { + PluginCommand command = null; + try + { + Constructor c = PluginCommand.class.getDeclaredConstructor(String.class, Plugin.class); + c.setAccessible(true); + + command = c.newInstance(name, plugin); + } + catch (SecurityException | IllegalArgumentException | IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException ex) + { + ex.printStackTrace(); + } + + return command; + } + + /** + * Initializes the singleton instance of this handler. + */ + public static void initialize() + { + instance = new CommandHandler(); + } + + /** + * @return the singleton instance of this handler. + */ + public static CommandHandler getInstance() + { + return instance; + } + + @SuppressWarnings("unchecked") + public static Map getKnownCommands() + { + Map existingCommands = null; + try + { + Field f = SimpleCommandMap.class.getDeclaredField("knownCommands"); + f.setAccessible(true); + + existingCommands = (Map) f.get(commandMapInstance); + } + catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException ex) + { + ex.printStackTrace(); + } + + return existingCommands; + } + + private static SimpleCommandMap getCommandMap() + { + SimpleCommandMap commandMap = null; + + try + { + if (Bukkit.getPluginManager() instanceof SimplePluginManager) + { + Field f = SimplePluginManager.class.getDeclaredField("commandMap"); + f.setAccessible(true); + + commandMap = (SimpleCommandMap) f.get(Bukkit.getPluginManager()); + } + } + catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException ex) + { + ex.printStackTrace(); + } + + return commandMap; + } + + /** + * @param sender the sender of the tab complete. + * @param lastWord the beginning of the typed argument. + * + * @return the name of all players visible to the sender. + */ + public static List defaultTabComplete(CommandSender sender, String lastWord) + { + // if the lastWord is null, something went wrong we should exit + if (lastWord == null) + { + return null; + } + + // set the argument to lower case for easier comparison + lastWord = lastWord.toLowerCase(); + + // create the list to return + List values = new LinkedList<>(); + + // create a player instance of the sender + Player playerSender = sender instanceof Player ? (Player) sender : null; + + // go through the players + for (Player player : Bukkit.getOnlinePlayers()) + { + // if the sender is not a player or if the player can see the target, add them + if ((playerSender == null || playerSender.canSee(player)) && (lastWord.equals("") || player.getName().toLowerCase().startsWith(lastWord))) + { + values.add(player.getName()); + } + } + return values; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/CommandLang.java b/src/main/java/com/alttd/altitudeapi/commands/CommandLang.java new file mode 100644 index 0000000..dd7ceca --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/CommandLang.java @@ -0,0 +1,131 @@ +package com.alttd.altitudeapi.commands; + +import java.util.Arrays; + +import com.alttd.altitudeapi.utils.CollectionUtils; +import com.alttd.altitudeapi.utils.MutableValue; +import com.alttd.altitudeapi.utils.StringUtils; +import org.bukkit.ChatColor; +import org.bukkit.command.CommandSender; + +public class CommandLang +{ + /** + * When a non-player tries to run a player-only command. + */ + public static CommandLang ONLY_PLAYERS = new CommandLang("Only players can run that command."); + + /** + * The format for a command usage message. + */ + public static CommandLang USAGE_FORMAT = new CommandLang("&6&lUSAGE &e» &7{message}"); + + /** + * When a {@link CommandSender} does not have permission to use a command. + */ + public static CommandLang NO_PERMISSION = new CommandLang("&4&lERROR &e» You don't have permission to do that."); + + /** + * When a player tries to list the available sub-commands. + */ + public static CommandLang NO_SUBS = new CommandLang("&4&lERROR &e» You don't have access to any sub-commands."); + + public static CommandLang HEADER_FOOTER = new CommandLang("&7&m-----------------------------------"); + + private final MutableValue value; + + /** + * Constructs a new CommandLang to be used in this class. + * + * @param value the default message. + */ + private CommandLang(String value) + { + // set the default value + this.value = new MutableValue<>(value); + } + + /** + * Returns the value of this lang option. + * + * @return the value of this lang option. + */ + public String getValue() + { + return value.getValue(); + } + + /** + * Sets the lang message. + * + * @param value the new lang value. + */ + public void setValue(String value) + { + this.value.setValue(value); + } + + /** + * Render a string with the proper parameters. + * + * @param args the placeholders and proper content. + * + * @return the rendered string. + */ + private String renderString(Object... args) + { + if (args.length % 2 != 0) + { + throw new IllegalArgumentException("Message rendering requires an even number of arguments. " + Arrays.toString(args) + " given."); + } + String string = getValue(); + for (int i = 0; i < args.length; i += 2) + { + string = string.replace(args[i].toString(), CollectionUtils.firstNonNull(args[i + 1], "").toString()); + } + + return ChatColor.translateAlternateColorCodes('&', string); + } + + /** + * Renders this message and returns it. + * + * @param parameters all additional arguments to fill placeholders. + * + * @return the compiled message. + */ + private String getMessage(Object... parameters) + { + return renderString(parameters); + } + + /** + * Sends this {@link CommandLang} object to the {@link CommandSender} target. The parameters replace all + * placeholders that exist in the String as well. + * + * @param sender the {@link CommandSender} receiving the message. + * @param parameters all additional arguments to fill placeholders. + */ + public void send(CommandSender sender, Object... parameters) + { + sender.sendMessage(getMessage(parameters)); + } + + /** + * Sends a usage message to the {@link CommandSender} for a command with the given label and parameters. + * + * @param sender the sender of the message + * @param label the labels the command has. + * @param parameters the parameters a command has. + */ + protected static void sendUsageMessage(CommandSender sender, String[] label, String[] parameters) + { + StringBuilder args = new StringBuilder("/" + StringUtils.compile(label)); + for (String str : parameters) + { + args.append(" [").append(str).append("]"); + } + + sender.sendMessage(USAGE_FORMAT.getMessage("{usage}", args.toString())); + } +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/Parser.java b/src/main/java/com/alttd/altitudeapi/commands/Parser.java new file mode 100644 index 0000000..d100d82 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/Parser.java @@ -0,0 +1,50 @@ +package com.alttd.altitudeapi.commands; + +import java.util.Iterator; +import java.util.List; + +import org.bukkit.command.CommandSender; + +public interface Parser +{ + + /** + * Parses the argument from the raw string into the appropriate type. If the argument can't be parsed + * + * @param sender the sender of the command. + * @param label the label of the command + * @param rawArgument the argument to be parsed. + * + * @return the successfully parsed argument. + */ + public T parseArgument(CommandSender sender, String[] label, String rawArgument); + + /** + * Get tab complete recommendations for an argument with this given parser. If the default is wanted, it exists in + * {@link CommandHandler#defaultTabComplete(CommandSender, String)}. + * + * @param sender the sender of the tab complete. + * @param lastWord the content of the item so far. + * + * @return the recommendations. + */ + public List getRecommendations(CommandSender sender, String lastWord); + + public static void pruneSuggestions(List values, String lastWord) + { + if (values == null || values.size() == 0) + { + return; + } + lastWord = lastWord.toLowerCase(); + Iterator it = values.iterator(); + while (it.hasNext()) + { + if (!it.next().toLowerCase().startsWith(lastWord)) + { + it.remove(); + } + } + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/SenderValidator.java b/src/main/java/com/alttd/altitudeapi/commands/SenderValidator.java new file mode 100644 index 0000000..5a925bf --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/SenderValidator.java @@ -0,0 +1,16 @@ +package com.alttd.altitudeapi.commands; + +import org.bukkit.command.CommandSender; + +public interface SenderValidator +{ + + /** + * Validates that the sender is in the proper state. + * + * @param sender the person sending the command. + * @return {@code true} if the sender is valid. + */ + public boolean validate(CommandSender sender); + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/ValidBaseCommand.java b/src/main/java/com/alttd/altitudeapi/commands/ValidBaseCommand.java new file mode 100644 index 0000000..f5e4f24 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/ValidBaseCommand.java @@ -0,0 +1,203 @@ +package com.alttd.altitudeapi.commands; + +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; + +import com.alttd.altitudeapi.utils.StringUtils; +import org.bukkit.command.CommandSender; + +public abstract class ValidBaseCommand extends ValidCommand +{ + + protected List subCommands; + + /** + * Constructs a new base command. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required rank to use this command. + * @param aliases any aliases for this command. + */ + protected ValidBaseCommand(String name, String description, String permission, String[] aliases) + { + super(name, description, permission, aliases); + + subCommands = new LinkedList<>(); + } + + /** + * Constructs a new base command with no aliases. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required rank to use this command. + */ + protected ValidBaseCommand(String name, String description, String permission) + { + this(name, description, permission, new String[0]); + } + + /** + * Constructs a new base command with no required permission. + * + * @param name the name of the command. + * @param description the description of the command. + * @param aliases any aliases for this command. + */ + protected ValidBaseCommand(String name, String description, String[] aliases) + { + this(name, description, null, aliases); + } + + /** + * Constructs a new base command with no aliases and no required permission. + * + * @param name the name of the command. + * @param description the description of the command. + */ + protected ValidBaseCommand(String name, String description) + { + this(name, description, null, new String[0]); + } + + @Override + protected void process(CommandSender sender, String[] label, String[] rawArguments) + { + ValidCommand sub; + if (rawArguments.length == 0 || (sub = getSubCommand(rawArguments[0])) == null) + { + help(sender, label); + } + else + { + if ((!hasPermission() || sender.hasPermission(getPermission())) && (!sub.hasPermission() || sender.hasPermission(sub.getPermission()))) + { + sub.process(sender, StringUtils.add(label, rawArguments[0]), Arrays.copyOfRange(rawArguments, 1, rawArguments.length)); + } + else + { + CommandLang.NO_PERMISSION.send(sender); + } + } + } + + @Override + public List processTabComplete(CommandSender sender, String[] rawArguments) + { + if (rawArguments.length == 1) + { + return getSubCommandNames(sender, rawArguments[0]); + } + else + { + return getSubCommand(rawArguments[0]).processTabComplete(sender, Arrays.copyOfRange(rawArguments, 1, rawArguments.length)); + + } + } + + /** + * Add a new sub command to this base command. + * + * @param subCommand the sub command to add. + */ + public void addSubCommand(ValidCommand subCommand) + { + subCommands.add(subCommand); + } + + /** + * Searches for a sub command by the given name. This can be either the command's name or one of it's aliases. + * + * @param label the label sent by the player. + * + * @return the sub command if one is found. + */ + public ValidCommand getSubCommand(String label) + { + for (ValidCommand command : subCommands) + { + if (command.matches(label)) + { + return command; + } + } + return null; + } + + /** + * Get the name all sub commands whose name or one if it's aliases starts with the given string. The name for each + * command will be whichever piece was provided, whether that be the alias or the name. + * + * @param sender the sender of the command. + * @param start the beginning of the label. + * + * @return the command labels if any are found. + */ + public List getSubCommandNames(CommandSender sender, String start) + { + List commandNames = new LinkedList<>(); + if (!hasPermission() || sender.hasPermission(getPermission())) + { + return commandNames; + } + String match; + for (ValidCommand sub : subCommands) + { + if ((match = sub.getMatchingAlias(start)) != null && (!sub.hasPermission() || sender.hasPermission(sub.getPermission()))) + { + commandNames.add(match); + } + } + return commandNames; + } + + /** + * Get a view of all the sub commands. This is not able to be modified and doing so will throw an exception. + * + * @return all the sub commands. + */ + public List getSubCommands() + { + return Collections.unmodifiableList(subCommands); + } + + /** + * Sends the help content to the player. + * + * @param sender the sender of the command. + * @param label the labels that this command has. + */ + public void help(CommandSender sender, String label[]) + { + List allowedSubs = new LinkedList<>(); + for (ValidCommand sub : subCommands) + { + if (!sub.hasPermission() || sender.hasPermission(sub.getPermission())) + { + allowedSubs.add(sub); + } + } + + if (allowedSubs.size() == 0) + { + CommandLang.NO_SUBS.send(sender); + return; + } + + CommandLang.HEADER_FOOTER.send(sender); + for (ValidCommand sub : allowedSubs) + { + sender.sendMessage(" §b/" + StringUtils.compile(label) + " " + sub.getName() + ": §7" + sub.getDescription()); + } + CommandLang.HEADER_FOOTER.send(sender); + } + + @Override + public void validRun(CommandSender sender, String[] label, List> arguments) + { + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/ValidCommand.java b/src/main/java/com/alttd/altitudeapi/commands/ValidCommand.java new file mode 100644 index 0000000..53d1e1f --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/ValidCommand.java @@ -0,0 +1,570 @@ +package com.alttd.altitudeapi.commands; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; + +import com.alttd.altitudeapi.utils.CollectionUtils; +import com.alttd.altitudeapi.utils.StringUtils; +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.Table; +import org.bukkit.Bukkit; +import org.bukkit.command.CommandSender; +import org.bukkit.command.ConsoleCommandSender; +import org.bukkit.entity.Player; + +public abstract class ValidCommand +{ + protected String name; + + protected String description; + + protected String permission; + + protected boolean blocksConsole; + + protected String[] aliases; + + protected LinkedList senderValidators; + + protected ArrayList> arguments; + + protected Table, Object> values; + + /** + * Constructs a new command with the given arguments. This will initialize the arguments list as well as the values + * table. Additionally, it will automatically convert all aliases to lowercase. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required permission for the command. + * @param blocksConsole if this command is unusable by the console. + * @param aliases the aliases of the command. + */ + public ValidCommand(String name, String description, String permission, boolean blocksConsole, String[] aliases) + { + this.name = name; + this.description = description; + this.permission = permission; + this.blocksConsole = blocksConsole; + this.aliases = aliases; + this.senderValidators = new LinkedList<>(); + this.arguments = new ArrayList<>(); + this.values = HashBasedTable.create(); + for (int i = 0; i < aliases.length; i++) + { + aliases[i] = aliases[i] == null ? "" : aliases[i].toLowerCase(); + } + } + + /** + * Constructs a new command without any aliases. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required permission for the command. + * @param blocksConsole if this command is unusable by the console. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, String permission, boolean blocksConsole) + { + this(name, description, permission, blocksConsole, new String[0]); + } + + /** + * Constructs a new command that is usable by the console. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required permission for the command. + * @param aliases the aliases of the command. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, String permission, String[] aliases) + { + this(name, description, permission, false, aliases); + } + + /** + * Constructs a new command without a required permission. + * + * @param name the name of the command. + * @param description the description of the command. + * @param blocksConsole if this command is unusable by the console. + * @param aliases the aliases of the command. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, boolean blocksConsole, String[] aliases) + { + this(name, description, null, blocksConsole, aliases); + } + + /** + * Constructs a new command without any aliases and is usable by the console. + * + * @param name the name of the command. + * @param description the description of the command. + * @param permission the required permission for the command. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, String permission) + { + this(name, description, permission, false, new String[0]); + } + + /** + * Constructs a new command without any aliases and no required permission. + * + * @param name the name of the command. + * @param description the description of the command. + * @param blocksConsole if this command is unusable by the console. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, boolean blocksConsole) + { + this(name, description, null, blocksConsole, new String[0]); + } + + /** + * Constructs a new command with no required permission and is usable by the console. + * + * @param name the name of the command. + * @param description the description of the command. + * @param aliases the aliases of the command. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description, String[] aliases) + { + this(name, description, null, false, aliases); + } + + /** + * Constructs a new command without any aliases, no required permission, and is usable by the console. + * + * @param name the name of the command. + * @param description the description of the command. + * + * @see #ValidCommand(String, String, String, boolean, String[]) + */ + public ValidCommand(String name, String description) + { + this(name, description, null, false, new String[0]); + } + + /** + * This method runs the command. It goes through each argument and will process and validate it. Then, so long as + * that passes, it will run the command's system. Last it will clear out any saved table data and stored argument + * values. + * + * @param sender the sender of the command. + * @param label the label from which the command was sent + * @param rawArguments the unparsed and non-validated arguments. + */ + protected void process(CommandSender sender, String[] label, String[] rawArguments) + { + if (rawArguments.length < getMinimumLength() || rawArguments.length > getMaximumLength()) + { + CommandLang.sendUsageMessage(sender, label, getArgumentNames()); + return; + } + for (SenderValidator senderValidator : senderValidators) + { + if (!senderValidator.validate(sender)) + { + return; + } + } + + if (rawArguments.length == 0 && blocksConsole() && sender instanceof ConsoleCommandSender) + { + CommandLang.ONLY_PLAYERS.send(sender); + return; + } + + CommandArgument argument; + for (int i = 0; i < rawArguments.length; i++) + { + argument = getArgument(i); + + // this should never happen, it is here exclusively to prevent potential errors that were not caught with exceptions earlier + if (argument == null) + { + CommandLang.sendUsageMessage(sender, label, getArgumentNames()); + return; + } + + if (blocksConsole() && !argument.allowsConsole() && sender instanceof ConsoleCommandSender) + { + CommandLang.ONLY_PLAYERS.send(sender); + return; + } + + if (!argument.process(sender, label, !argument.hasVariableLength() ? rawArguments[i] : StringUtils.compile(Arrays.copyOfRange(rawArguments, i, rawArguments.length)))) + { + return; + } + } + try + { + validRun(sender, label, arguments); + } + catch (Exception ex) + { + ex.printStackTrace(); + sender.sendMessage("§4An error occurred. Contact a staff member immediately."); + for (Player player : Bukkit.getOnlinePlayers()) + { + if (player.hasPermission("altitude.admin")) + { + player.sendMessage("§4§lERROR: §cA player tried to run a FortuneBlocks command and it caused an error. Tell an administrator to check the console."); + } + } + } + arguments.forEach(CommandArgument::clearValue); + clearTable(); + } + + /** + * Process the tab complete for the given command. This also takes into account the fact the last argument provided + * is what is supposed to be changed. The arguments passed include only the arguments for the command, and not the + * actual label used. The raw arguments passed should always have at least a length of 1. + * + * @param sender the person who sent the tab request. + * @param rawArguments the arguments already typed by the player. + * + * @return the suggestions for tab complete. + */ + public List processTabComplete(CommandSender sender, String[] rawArguments) + { + Iterator> it = arguments.iterator(); + int i = 0; + CommandArgument argument = null; + while (it.hasNext() && i < rawArguments.length) + { + argument = it.next(); + i++; + } + if (argument != null) + { + if (!argument.hasPermission() || sender.hasPermission(argument.getPermission())) + { + return argument.getRecommendations(sender, rawArguments[rawArguments.length - 1]); + } + else + { + return Arrays.asList(); + } + } + else + { + return CommandHandler.defaultTabComplete(sender, rawArguments[rawArguments.length - 1]); + } + } + + /** + * Runs the command after all processing has already been completed. The label is an array of the label used by this + * command as well as any parent command. The arguments will always be there, whether they are used or not. To check + * if optional arguments were used, call the method {@link CommandArgument#hasValue()}. + * + * @param sender the sender of the command. + * @param label the label of the command. + * @param arguments the arguments of the command. + */ + public abstract void validRun(CommandSender sender, String[] label, List> arguments); + + /** + * The table of the already processed values. -1 corresponds to the sender. Every other number corresponds to the + * ordinal of the argument. In the process of running the command, it will always grab the sender's session. + * + * @return the already processed values. + */ + public Table, Object> getValues() + { + return values; + } + + /** + * Clear all the stored values in the table that were added from the command's usage. + */ + private void clearTable() + { + values.clear(); + } + + /** + * @return an array of all the names of the arguments. + */ + public String[] getArgumentNames() + { + String[] argumentNames = new String[arguments.size()]; + int i = 0; + for (CommandArgument argument : arguments) + { + argumentNames[i] = argument.getName(); + i++; + } + return argumentNames; + } + + /** + * The lowest possible length that the number of raw arguments is capable of being. This is the count of the number + * of arguments that are not optional. + * + * @return the minimum length of the raw command arguments. + */ + protected int getMinimumLength() + { + int minimumLength = 0; + for (CommandArgument argument : arguments) + { + if (!argument.isOptional()) + { + minimumLength++; + } + } + return minimumLength; + } + + /** + * The highest possible length that the number of raw arguments is capable of being. For non-variable-length + * commands, this is the size of all the arguments. For variable-length commands, it is {@link Integer#MAX_VALUE}. + * + * @return the maximum length of the raw command arguments. + */ + protected int getMaximumLength() + { + if (arguments.size() == 0) + { + return 0; + } + if (CollectionUtils.getLast(arguments).hasVariableLength()) + { + return Integer.MAX_VALUE; + } + return arguments.size(); + } + + /** + * Adds a new argument to be used by the command. Will throw an {@link IllegalArgumentException} in one of two + * cases. First, if the given argument is required and the previous argument is not optional. Second, if the + * argument before it is of variable length. Both of these cases are not supported as there is no perfect way to + * ensure that the arguments will always capture the desired input. + * + * @param argument the new argument + */ + protected void addArgument(CommandArgument argument) + { + if (arguments.size() != 0) + { + + if (!argument.isOptional() && CollectionUtils.getLast(arguments).isOptional()) + { + throw new IllegalArgumentException("Required arguments can only follow other required arguments."); + } + if (CollectionUtils.getLast(arguments).hasVariableLength()) + { + throw new IllegalArgumentException("Arguments of variable length must be the last argument."); + } + } + argument.setOrdinal(arguments.size()); + argument.setCommand(this); + arguments.add(argument); + } + + /** + * Remove an existing argument from the command. + * + * @param argument the existing argument. + * + * @return whether or not the argument still existed. + */ + protected boolean removeArgument(CommandArgument argument) + { + return arguments.remove(argument); + } + + /** + * Remove an existing argument from the command, referenced by name. + * + * @param argumentName the name of the argument. + * + * @return whether or not the argument existed. + */ + protected boolean removeArgument(String argumentName) + { + return removeArgument(getArgument(argumentName)); + } + + /** + * Return an unmodifiable view of the arguments for this command. To add a new argument use + * {@link #addArgument(CommandArgument)}. To remove an existing argument use + * {@link #removeArgument(CommandArgument)}. + * + * @return the current existing arguments. + */ + public List> getArguments() + { + return Collections.unmodifiableList(arguments); + } + + /** + * @param ordinal the ordinal. + * + * @return the argument at the given ordinal. + */ + protected CommandArgument getArgument(int ordinal) + { + for (CommandArgument argument : arguments) + { + if (argument.getOrdinal() == ordinal) + { + return argument; + } + } + return null; + } + + /** + * Get a particular argument that has the given name. This will return null if the argument is not found. Not case + * sensitive. + * + * @param argumentName the name of the argument. + * + * @return the argument with the given name. + */ + protected CommandArgument getArgument(String argumentName) + { + argumentName = argumentName.toLowerCase(); + for (CommandArgument arg : arguments) + { + if (arg.getName().equals(argumentName)) + { + return arg; + } + } + return null; + } + + /** + * Adds a validator to be run on the player before the command itself starts processing the information. + * + * @param senderValidator the new validator + */ + protected void addSenderValidator(SenderValidator senderValidator) + { + senderValidators.add(senderValidator); + } + + /** + * Checks whether the passed in command string matches this particular valid command, + * + * @param label the label of the command. + * + * @return {@code true} if the parameter matches the command. Otherwise, returns {@code false}. + */ + protected boolean matches(String label) + { + label = label.toLowerCase(); + if (label == null) + { + return false; + } + if (label.equals(getName())) + { + return true; + } + for (String alias : aliases) + { + if (label.equals(alias)) + { + return true; + } + } + return false; + } + + /** + * @param start the start of the alias to search for. + * + * @return the name or alias that starts with the given string. + */ + protected String getMatchingAlias(String start) + { + start = start.toLowerCase(); + if (name.startsWith(start)) + { + return name; + } + for (String alias : aliases) + { + if (alias.startsWith(start)) + { + return alias; + } + } + return null; + } + + /** + * @return all other names this command could be referenced by besides it's name. + */ + public String[] getAliases() + { + return aliases; + } + + /** + * @return {@code true} if this command is unusable by the console unless overridden by an argument. + */ + public boolean blocksConsole() + { + return blocksConsole; + } + + public boolean hasPermission() + { + return permission != null; + } + + /** + * @return the permission required to run this command. + */ + public String getPermission() + { + return permission; + } + + /** + * Returns the description of the command. This is given to Bukkit when the command is properly registered within + * their system. There is no method to change this, and if it is changed via reflection, that change will not be + * reflected within Bukkit's command system. + * + * @return the description of the command. + */ + public String getDescription() + { + return description; + } + + /** + * Returns the name of the command. This is what is used to register the command within Bukkit, as well as the + * primary way to reference the command elsewhere. There is no method to change this, and if it is changed via + * reflection, that change will not be reflected within Bukkit's command system. + * + * @return the name of the command. + */ + public String getName() + { + return name.toLowerCase(); + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/commands/Validator.java b/src/main/java/com/alttd/altitudeapi/commands/Validator.java new file mode 100644 index 0000000..c663426 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/commands/Validator.java @@ -0,0 +1,19 @@ +package com.alttd.altitudeapi.commands; + +import org.bukkit.command.CommandSender; + +public interface Validator +{ + + /** + * Validates that the argument is in the correct state. This should also send any and all error messages associated + * with the problem with the argument. + * + * @param sender the sender of the command. + * @param label the label of the command + * @param arg the argument to be validated. + * @return {@code true} if the argument is valid. {@code false} of the argument is not valid. + */ + public boolean validateArgument(CommandSender sender, String[] label, T arg); + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/ChatUtils.java b/src/main/java/com/alttd/altitudeapi/utils/ChatUtils.java new file mode 100644 index 0000000..1992181 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/ChatUtils.java @@ -0,0 +1,68 @@ +package com.alttd.altitudeapi.utils; + +import org.bukkit.ChatColor; +import org.bukkit.command.CommandSender; + +public class ChatUtils +{ + + private final static int CENTER_PX = 154; + + public static void sendCenteredMessage(CommandSender sender, String message) + { + if (message == null || message.equals("")) + { + sender.sendMessage(""); + } + message = ChatColor.translateAlternateColorCodes('&', message); + + int messagePxSize = 0; + boolean previousCode = false; + boolean isBold = false; + + for (char c : message.toCharArray()) + { + if (c == ChatColor.COLOR_CHAR) + { + previousCode = true; + } + else if (previousCode) + { + previousCode = false; + isBold = (c == 'l' || c == 'L'); + } + else + { + DefaultFontInfo dFI = DefaultFontInfo.getDefaultFontInfo(c); + messagePxSize += isBold ? dFI.getBoldLength() : dFI.getLength(); + messagePxSize++; + } + } + + int halvedMessageSize = messagePxSize / 2; + int toCompensate = CENTER_PX - halvedMessageSize; + int spaceLength = DefaultFontInfo.SPACE.getLength() + 1; + int compensated = 0; + StringBuilder sb = new StringBuilder(); + while (compensated < toCompensate) + { + sb.append(" "); + compensated += spaceLength; + } + sender.sendMessage(sb.toString() + message); + } + + public static String renderString(String string, String... arguments) + { + if (arguments.length % 2 != 0) + { + throw new IllegalArgumentException("Must have an even number of arguments."); + } + for (int i = 0; i < arguments.length; i += 2) + { + string = string.replace(arguments[i], arguments[i + 1]); + } + return string; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/CollectionUtils.java b/src/main/java/com/alttd/altitudeapi/utils/CollectionUtils.java new file mode 100644 index 0000000..668d0a0 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/CollectionUtils.java @@ -0,0 +1,249 @@ +package com.alttd.altitudeapi.utils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Random; + +public class CollectionUtils +{ + + private final static Map, Method> nameMethods = new HashMap<>(); + + /** + * Retrieves the last value of the given list. If the list is null or it has no elements, this will always return + * null. If the List is also a Deque, this will return the last element using {@link Deque#peekLast()}. + * + * @param list the list to get the last value of. + * @param the type of the list. + * + * @return the last value. + */ + @SuppressWarnings("unchecked") + public static T getLast(List list) + { + if (list == null || list.size() == 0) + { + return null; + } + if (list instanceof Deque) + { + return ((Deque) list).peekLast(); + } + return list.get(list.size() - 1); + } + + /** + * Safely checks if the given collection is immutable. If the collection is mutable, the data will not be affected + * unless the collection in question keeps track of total number of operations. The test is done by calling + * {@link Collection#removeIf(java.util.function.Predicate)} with the predicate of {@code false}. + * + * @param values the collection to check. + * + * @return {@code true} if the collection is immutable. + */ + public static boolean isImmutable(Collection values) + { + try + { + values.removeIf(x -> false); + return true; + } + catch (UnsupportedOperationException ex) + { + return false; + } + } + + /** + * Converts the given values into their string counterpart. This is done by calling {@link Object#toString()} on + * every object. More specific use cases like {@link org.bukkit.entity.Player#getName()} etc are not compatible. + * + * @param values the values to convert. + * @param the type of the collection. + * + * @return the generated list of Strings. + */ + public static List getStringList(Collection values) + { + if (values == null || values.size() == 0) + { + return Collections.emptyList(); + } + List list = new LinkedList<>(); + for (Object o : values) + { + if (o != null) + { + list.add(o.toString()); + } + else + { + list.add(null); + } + } + return list; + } + + /** + * Get the names of every single object passed in the values parameter. This method requires the method "getName()" + * to exist within whatever type is passed. If it does not exist, an empty list is returned. However, in the future + * there is a potential that it will be changed to throwing an {@link IllegalArgumentException}. + * + * @param values the values to get the name of. + * @param type the type of the object. + * @param the type of the list. + * + * @return the list of names. + */ + public static List getNames(Collection values, Class type) + { + if (values == null || values.size() == 0) + { + return Collections.emptyList(); + } + List list = new LinkedList<>(); + + Method method = getNameMethod(type); + + if (method == null) + { + return Collections.emptyList(); + } + + for (Object obj : values) + { + try + { + list.add((String) method.invoke(obj)); + } + catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) + { + // this exception is actually going to be printed as it should never happen. + // the method was set to accessible previously, and it should also never have any arguments. + ex.printStackTrace(); + } + } + return list; + } + + private static Method getNameMethod(Class clazz) + { + Method method = nameMethods.get(clazz); + if (method == null) + { + try + { + method = clazz.getDeclaredMethod("getName"); + method.setAccessible(true); + nameMethods.put(clazz, method); + } + catch (NoSuchMethodException | SecurityException ex) + { + // ignored + } + } + return method; + } + + /** + * Searches through the given values for the first non-null value. + * + * @param values the values to find. + * @param the type of the array. + * + * @return the first non-null value. + */ + @SafeVarargs + public static T firstNonNull(T... values) + { + for (T value : values) + { + if (value != null) + { + return value; + } + } + return null; + } + + /** + * Converts the given String collection into a String array. + * + * @param collection the collection to convert. + * + * @return the newly created array. + */ + public static String[] toArray(Collection collection) + { + return collection.toArray(new String[0]); + } + + /** + * Returns a random value from the collection. If the collection is null or empty, this will return null. + * + * @param collection the collection to poll. + * @param the type of the collection. + * + * @return a random value from the collection. + */ + public static T randomValue(Collection collection) + { + return randomValue(collection, null); + } + + /** + * Returns a random value from the collection. If the collection is null or empty, this will return null. + * + * @param collection the collection to poll. + * @param ignored any values not suitable to be included + * @param the type of the collection. + * + * @return a random value from the collection. + */ + public static T randomValue(Collection collection, T... ignored) + { + // if it's null or empty, we don't care + if (collection == null || collection.size() == 0) + { + return null; + } + // if the ignored values aren't null, we need to make them not an option + if (ignored != null) + { + collection = new ArrayList<>(collection); + collection.removeAll(Arrays.asList(ignored)); + } + Random random = new Random(); + + // the index to get a value from + int index = random.nextInt(collection.size()); + + // if it's a list, we can just get it at that index, no need to iterate + if (collection instanceof List) + { + return ((List) collection).get(index); + } + + // it's not a list, time to iterate + Iterator iterator = collection.iterator(); + for (int i = 0; iterator.hasNext(); i++) + { + if (i == index) + { + return iterator.next(); + } + iterator.next(); + } + return null; + } +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/DefaultFontInfo.java b/src/main/java/com/alttd/altitudeapi/utils/DefaultFontInfo.java new file mode 100644 index 0000000..db48ce8 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/DefaultFontInfo.java @@ -0,0 +1,139 @@ +package com.alttd.altitudeapi.utils; + +public enum DefaultFontInfo +{ + + A('A', 5), + a('a', 5), + B('B', 5), + b('b', 5), + C('C', 5), + c('c', 5), + D('D', 5), + d('d', 5), + E('E', 5), + e('e', 5), + F('F', 5), + f('f', 4), + G('G', 5), + g('g', 5), + H('H', 5), + h('h', 5), + I('I', 3), + i('i', 1), + J('J', 5), + j('j', 5), + K('K', 5), + k('k', 4), + L('L', 5), + l('l', 1), + M('M', 5), + m('m', 5), + N('N', 5), + n('n', 5), + O('O', 5), + o('o', 5), + P('P', 5), + p('p', 5), + Q('Q', 5), + q('q', 5), + R('R', 5), + r('r', 5), + S('S', 5), + s('s', 5), + T('T', 5), + t('t', 4), + U('U', 5), + u('u', 5), + V('V', 5), + v('v', 5), + W('W', 5), + w('w', 5), + X('X', 5), + x('x', 5), + Y('Y', 5), + y('y', 5), + Z('Z', 5), + z('z', 5), + NUM_1('1', 5), + NUM_2('2', 5), + NUM_3('3', 5), + NUM_4('4', 5), + NUM_5('5', 5), + NUM_6('6', 5), + NUM_7('7', 5), + NUM_8('8', 5), + NUM_9('9', 5), + NUM_0('0', 5), + EXCLAMATION_POINT('!', 1), + AT_SYMBOL('@', 6), + NUM_SIGN('#', 5), + DOLLAR_SIGN('$', 5), + PERCENT('%', 5), + UP_ARROW('^', 5), + AMPERSAND('&', 5), + ASTERISK('*', 5), + LEFT_PARENTHESIS('(', 4), + RIGHT_PERENTHESIS(')', 4), + MINUS('-', 5), + UNDERSCORE('_', 5), + PLUS_SIGN('+', 5), + EQUALS_SIGN('=', 5), + LEFT_CURL_BRACE('{', 4), + RIGHT_CURL_BRACE('}', 4), + LEFT_BRACKET('[', 3), + RIGHT_BRACKET(']', 3), + COLON(':', 1), + SEMI_COLON(';', 1), + DOUBLE_QUOTE('"', 3), + SINGLE_QUOTE('\'', 1), + LEFT_ARROW('<', 4), + RIGHT_ARROW('>', 4), + QUESTION_MARK('?', 5), + SLASH('/', 5), + BACK_SLASH('\\', 5), + LINE('|', 1), + TILDE('~', 5), + TICK('`', 2), + PERIOD('.', 1), + COMMA(',', 1), + SPACE(' ', 3), + DEFAULT('a', 4); + + private char character; + private int length; + + DefaultFontInfo(char character, int length) + { + this.character = character; + this.length = length; + } + + public char getCharacter() + { + return this.character; + } + + public int getLength() + { + return this.length; + } + + public int getBoldLength() + { + if (this == DefaultFontInfo.SPACE) + return this.getLength(); + return this.length + 1; + } + + public static DefaultFontInfo getDefaultFontInfo(char c) + { + for (DefaultFontInfo dFI : DefaultFontInfo.values()) + { + if (dFI.getCharacter() == c) + return dFI; + } + return DefaultFontInfo.DEFAULT; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/EnumUtil.java b/src/main/java/com/alttd/altitudeapi/utils/EnumUtil.java new file mode 100644 index 0000000..eb9871f --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/EnumUtil.java @@ -0,0 +1,46 @@ +package com.alttd.altitudeapi.utils; + +import java.lang.reflect.Field; +import java.util.HashSet; +import java.util.Set; + +/** + * Utils for working with enums. Most of the code was taken EssentialsX. + * + * @author Michael Ziluck + */ +public class EnumUtil +{ + /** + * Return a set containing all fields of the given enum that maths one of the provided + * names. + * + * @param enumClass The class to search through + * @param names The names of the fields to search for + * @param The enum to search through + * + * @return All matching enum fields + */ + public static Set getAllMatching(Class enumClass, String... names) + { + Set set = new HashSet<>(); + + for (String name : names) + { + try + { + Field enumField = enumClass.getDeclaredField(name); + + if (enumField.isEnumConstant()) + { + set.add((T) enumField.get(null)); + } + } + catch (NoSuchFieldException | IllegalAccessException ignored) + { + } + } + + return set; + } +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/ItemUtils.java b/src/main/java/com/alttd/altitudeapi/utils/ItemUtils.java new file mode 100644 index 0000000..2143eb8 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/ItemUtils.java @@ -0,0 +1,27 @@ +package com.alttd.altitudeapi.utils; + +import java.util.Set; + +import org.bukkit.Material; + +public class ItemUtils +{ + private static final Set POTIONS; + + static + { + POTIONS = EnumUtil.getAllMatching(Material.class, "POTION", "SPLASH_POTION", "LINGERING_POTION", "TIPPED_ARROW"); + } + + /** + * Checks if the given material is a potion. + * + * @param material the material to check. + * + * @return {@code true} if the material is a potion. Otherwise returns {@code false}. + */ + public static boolean isPotion(Material material) + { + return POTIONS.contains(material); + } +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/MutableEnum.java b/src/main/java/com/alttd/altitudeapi/utils/MutableEnum.java new file mode 100644 index 0000000..9389516 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/MutableEnum.java @@ -0,0 +1,55 @@ +package com.alttd.altitudeapi.utils; + +/** + * Designed to wrap enums to force them to behave mutably. + * + * @param the type this MutableEnum wraps. + * + * @author Michael Ziluck + */ +public class MutableEnum> +{ + + private Enum value; + + /** + * Creates a new MutableEnum wrapper for the given value. + * + * @param value the value to wrap. + */ + public MutableEnum(T value) + { + this.value = value; + } + + /** + * @return the currently wrapped value. + */ + public Enum getValue() + { + return value; + } + + /** + * The value can't be null. + * + * @param value the new wrapped value. + */ + public void setValue(T value) + { + if (value == null) + { + throw new NullPointerException("Value can't be null."); + } + this.value = value; + } + + /** + * @return the class type of the contained Enum. + */ + public Class getType() + { + return value.getDeclaringClass(); + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/MutableString.java b/src/main/java/com/alttd/altitudeapi/utils/MutableString.java new file mode 100644 index 0000000..5b3474a --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/MutableString.java @@ -0,0 +1,45 @@ +package com.alttd.altitudeapi.utils; + +/** + * Designed to wrap Strings to force them to behave mutably. + * + * @author Michael Ziluck + */ +public class MutableString +{ + + private String value; + + /** + * Creates a new MutableString wrapper for the given value. + * + * @param value the value to wrap. + */ + public MutableString(String value) + { + this.value = value; + } + + /** + * @return the currently wrapped value. + */ + public String getValue() + { + return value; + } + + /** + * The value can't be null. + * + * @param value the new wrapped value. + */ + public void setValue(String value) + { + if (value == null) + { + throw new NullPointerException("Value can't be null."); + } + this.value = value; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/MutableValue.java b/src/main/java/com/alttd/altitudeapi/utils/MutableValue.java new file mode 100644 index 0000000..6a8a951 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/MutableValue.java @@ -0,0 +1,60 @@ +package com.alttd.altitudeapi.utils; + +/** + * Represents a mutable data type for a type that may not normally be mutable, either because it is final, primitive, or sealed. + * + * @param the type of this mutable value. + */ +public class MutableValue +{ + private T value; + + /** + * Constructs a new MutableValue with the given object. + * + * @param t the value to be stored. + */ + public MutableValue(T t) + { + if (t == null) + { + throw new IllegalArgumentException("Value can't be null."); + } + + this.value = t; + } + + /** + * Returns the value that is currently stored. If there is no value, returns null. + * + * @return the value that is currently stored. + */ + public T getValue() + { + return value; + } + + /** + * Sets the value that is currently stored. + * + * @param t the new value to be stored. + */ + public void setValue(T t) + { + if (t == null) + { + throw new IllegalArgumentException("Value can't be null."); + } + this.value = t; + } + + public Class getType() + { + if (value == null) + { + throw new IllegalStateException("Value can't be null."); + } + + return (Class) value.getClass(); + } +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/StringUtils.java b/src/main/java/com/alttd/altitudeapi/utils/StringUtils.java new file mode 100644 index 0000000..70882d1 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/StringUtils.java @@ -0,0 +1,157 @@ +package com.alttd.altitudeapi.utils; + +import java.text.DecimalFormat; + +public class StringUtils +{ + + public static String implode(String[] strings, int start, int end) + { + StringBuilder sb = new StringBuilder(); + + for (int i = start; i < end; i++) + { + sb.append(strings[i] + " "); + } + + return sb.toString().trim(); + } + + public static String[] add(String[] array, String add) + { + String[] values = new String[array.length + 1]; + for (int i = 0; i < array.length; i++) + { + values[i] = array[i]; + } + values[array.length] = add; + return values; + } + + public static String compile(String[] strings) + { + return implode(strings, 0, strings.length); + } + + public static String capitalize(final String str) + { + int strLen; + if (str == null || (strLen = str.length()) == 0) + { + return str; + } + + final int firstCodepoint = str.codePointAt(0); + final int newCodePoint = Character.toTitleCase(firstCodepoint); + if (firstCodepoint == newCodePoint) + { + // already capitalized + return str; + } + + final int newCodePoints[] = new int[strLen]; // cannot be longer than + // the char array + int outOffset = 0; + newCodePoints[outOffset++] = newCodePoint; // copy the first codepoint + for (int inOffset = Character.charCount(firstCodepoint); inOffset < strLen;) + { + final int codepoint = str.codePointAt(inOffset); + newCodePoints[outOffset++] = codepoint; // copy the remaining ones + inOffset += Character.charCount(codepoint); + } + return new String(newCodePoints, 0, outOffset); + } + + public static boolean contains(String[] values, String search) + { + for (String val : values) + { + if (val.equalsIgnoreCase(search)) + { + return true; + } + } + return false; + } + + public static boolean isNullOrEmpty(String str) + { + return str == null || str.length() == 0; + } + + public static boolean isWhitespace(String str) + { + if (str == null) + { + return false; + } + final int sz = str.length(); + for (int i = 0; i < sz; i++) + { + if (!Character.isWhitespace(str.charAt(i))) + { + return false; + } + } + return true; + } + + public static boolean containsAny(String search, String... strings) + { + if (isNullOrEmpty(search)) + { + return false; + } + for (String searchCharSequence : strings) + { + if (indexOf(search, searchCharSequence, 0) >= 0) + { + return true; + } + } + return false; + } + + private static int indexOf(CharSequence cs, CharSequence searchChar, int start) + { + return cs.toString().indexOf(searchChar.toString(), start); + } + + public static String formatNumber(Number number, int decimalPlaces, boolean useCommas) + { + StringBuilder sb = new StringBuilder(); + if (useCommas) + { + sb.append("#,##0"); + } + else + { + sb.append("0"); + } + if (decimalPlaces > 0) + { + sb.append('.'); + for (int i = 0; i < decimalPlaces; i++) + { + sb.append('0'); + } + } + return new DecimalFormat(sb.toString()).format(number); + } + + public static String doubleFormat(double number) + { + String formatted; + + if (number % 1 == 0) + { + formatted = Integer.toString((int) number); + } + else + { + formatted = Double.toString(number); + } + return formatted; + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/VersionUtils.java b/src/main/java/com/alttd/altitudeapi/utils/VersionUtils.java new file mode 100644 index 0000000..03a804f --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/VersionUtils.java @@ -0,0 +1,22 @@ +package com.alttd.altitudeapi.utils; + +import org.bukkit.Material; +import org.bukkit.event.block.BlockBreakEvent; + +public class VersionUtils +{ + + public static void stopDrops(BlockBreakEvent event) + { + try + { + event.setDropItems(false); + } + catch (NoSuchMethodError ex) + { + event.setCancelled(true); + event.getBlock().setType(Material.AIR); + } + } + +} diff --git a/src/main/java/com/alttd/altitudeapi/utils/items/ItemData.java b/src/main/java/com/alttd/altitudeapi/utils/items/ItemData.java new file mode 100644 index 0000000..22f1d2d --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/items/ItemData.java @@ -0,0 +1,99 @@ +package com.alttd.altitudeapi.utils.items; + +import org.bukkit.Material; +import org.bukkit.entity.EntityType; +import org.bukkit.potion.PotionData; + +public class ItemData +{ + private final Material material; + + private PotionData potionData = null; + + private EntityType entity = null; + + public ItemData(Material material) + { + this.material = material; + } + + public ItemData(Material material, PotionData potionData) + { + this.material = material; + this.potionData = potionData; + } + + public ItemData(Material material, EntityType entity) + { + this.material = material; + this.entity = entity; + } + + public Material getMaterial() + { + return material; + } + + public PotionData getPotionData() + { + return this.potionData; + } + + public EntityType getEntity() + { + return this.entity; + } + + @Override + public int hashCode() + { + return (31 * material.hashCode()) ^ potionData.hashCode(); + } + + @Override + public boolean equals(Object o) + { + if (o == null) + { + return false; + } + if (!(o instanceof ItemData)) + { + return false; + } + ItemData that = (ItemData) o; + return this.material == that.getMaterial() && potionDataEquals(that) && entityEquals(that); + } + + private boolean potionDataEquals(ItemData o) + { + if (this.potionData == null && o.getPotionData() == null) + { + return true; + } + else if (this.potionData != null && o.getPotionData() != null) + { + return this.potionData.equals(o.getPotionData()); + } + else + { + return false; + } + } + + private boolean entityEquals(ItemData o) + { + if (this.entity == null && o.getEntity() == null) + { // neither have an entity + return true; + } + else if (this.entity != null && o.getEntity() != null) + { // both have an entity; check if it's the same one + return this.entity.equals(o.getEntity()); + } + else + { // one has an entity but the other doesn't, so they can't be equal + return false; + } + } +} \ No newline at end of file diff --git a/src/main/java/com/alttd/altitudeapi/utils/items/ItemDb.java b/src/main/java/com/alttd/altitudeapi/utils/items/ItemDb.java new file mode 100644 index 0000000..569fff8 --- /dev/null +++ b/src/main/java/com/alttd/altitudeapi/utils/items/ItemDb.java @@ -0,0 +1,279 @@ +package com.alttd.altitudeapi.utils.items; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import com.alttd.altitudeapi.AltitudeAPI; +import com.alttd.altitudeapi.utils.ItemUtils; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import org.bukkit.Material; +import org.bukkit.block.BlockState; +import org.bukkit.block.CreatureSpawner; +import org.bukkit.entity.EntityType; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.BlockStateMeta; +import org.bukkit.inventory.meta.Damageable; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.inventory.meta.PotionMeta; +import org.bukkit.potion.PotionData; + +public class ItemDb +{ + private static Gson gson = new Gson(); + + // Maps primary name to ItemData + private final transient Map items = new HashMap<>(); + + // Maps alias to primary name + private final transient Map itemAliases = new HashMap<>(); + + // Every known alias + private final transient Set allAliases = new HashSet<>(); + + private transient File file; + + private boolean ready = false; + + public ItemDb(File file) + { + this.file = file; + reloadConfig(); + } + + public void reloadConfig() + { + if (file == null) + { + file = new File(AltitudeAPI.getInstance().getDataFolder(), "items.json"); + } + + this.rebuild(); + AltitudeAPI.getInstance().getLogger().info(String.format("Loaded %s items from items.json.", listNames().size())); + } + + private void rebuild() + { + this.reset(); + + String json = getLines(file).stream() + .filter(line -> !line.startsWith("#")) + .collect(Collectors.joining()); + + this.loadJSON(String.join("\n", json)); + + ready = true; + } + + private void reset() + { + ready = false; + items.clear(); + itemAliases.clear(); + allAliases.clear(); + } + + public void loadJSON(String source) + { + JsonObject map = (new JsonParser()).parse(source).getAsJsonObject(); + + for (Map.Entry entry : map.entrySet()) + { + String key = entry.getKey(); + JsonElement element = entry.getValue(); + boolean valid = false; + + if (element.isJsonObject()) + { + ItemData data = gson.fromJson(element, ItemData.class); + items.put(key, data); + valid = true; + } + else + { + try + { + String target = element.getAsString(); + itemAliases.put(key, target); + valid = true; + } + catch (Exception ignored) + { + } + } + + if (valid) + { + allAliases.add(key); + } + else + { + AltitudeAPI.getInstance().getLogger().warning(String.format("Failed to add item: \"%s\": %s", key, element.toString())); + } + } + } + + public ItemStack get(String id) throws Exception + { + id = id.toLowerCase(); + final String[] split = id.split(":"); + + ItemData data = getByName(split[0]); + + if (data == null) + { + throw new Exception("Unknown item name: " + id); + } + + Material material = data.getMaterial(); + + if (!material.isItem()) + { + throw new Exception("Cannot spawn " + id + "; this is not a spawnable item."); + } + + ItemStack stack = new ItemStack(material); + stack.setAmount(material.getMaxStackSize()); + + PotionData potionData = data.getPotionData(); + ItemMeta meta = stack.getItemMeta(); + + if (potionData != null && meta instanceof PotionMeta) + { + PotionMeta potionMeta = (PotionMeta) meta; + potionMeta.setBasePotionData(potionData); + } + + // For some reason, Damageable doesn't extend ItemMeta but CB implements them in the same + // class. As to why, your guess is as good as mine. + if (split.length > 1 && meta instanceof Damageable) + { + Damageable damageMeta = (Damageable) meta; + damageMeta.setDamage(Integer.parseInt(split[1])); + } + + EntityType entity = data.getEntity(); + if (entity != null && material.toString().contains("SPAWNER")) + { + BlockStateMeta bsm = (BlockStateMeta) meta; + + BlockState bs = bsm.getBlockState(); + + ((CreatureSpawner) bs).setSpawnedType(entity); + + bsm.setBlockState(bs); + } + + stack.setItemMeta(meta); + + return stack; + } + + private ItemData getByName(String name) + { + name = name.toLowerCase(); + if (items.containsKey(name)) + { + return items.get(name); + } + else if (itemAliases.containsKey(name)) + { + return items.get(itemAliases.get(name)); + } + + return null; + } + + public List nameList(ItemStack item) + { + List names = new ArrayList<>(); + String primaryName = name(item); + names.add(primaryName); + + for (Map.Entry entry : itemAliases.entrySet()) + { + if (entry.getValue().equalsIgnoreCase(primaryName)) + { + names.add(entry.getKey()); + } + } + + return names; + } + + public String name(ItemStack item) + { + ItemData data = lookup(item); + + for (Map.Entry entry : items.entrySet()) + { + if (entry.getValue().equals(data)) + { + return entry.getKey(); + } + } + + return null; + } + + public ItemData lookup(ItemStack item) + { + Material type = item.getType(); + + if (ItemUtils.isPotion(type) && item.getItemMeta() instanceof PotionMeta) + { + PotionData potion = ((PotionMeta) item.getItemMeta()).getBasePotionData(); + return new ItemData(type, potion); + } + else if (type.toString().contains("SPAWNER")) + { + EntityType entity = ((CreatureSpawner) ((BlockStateMeta) item.getItemMeta()).getBlockState()).getSpawnedType(); + return new ItemData(type, entity); + } + else + { + return new ItemData(type); + } + } + + public Collection listNames() + { + return Collections.unmodifiableSet(allAliases); + } + + private List getLines(File file) + { + try (final BufferedReader reader = new BufferedReader(new FileReader(file))) + { + final List lines = new ArrayList<>(9000); + String line = null; + do + { + if ((line = reader.readLine()) == null) + { + break; + } + lines.add(line); + } while (true); + return lines; + } + catch (IOException ex) + { + return Collections.emptyList(); + } + } + +} \ No newline at end of file diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..cb0f91b --- /dev/null +++ b/src/main/resources/config.yml @@ -0,0 +1 @@ +use-items: false \ No newline at end of file diff --git a/src/main/resources/items.csv b/src/main/resources/items.csv new file mode 100644 index 0000000..3144b43 --- /dev/null +++ b/src/main/resources/items.csv @@ -0,0 +1,8976 @@ +#version: ${full.version} +#Do not make changes to this file. If you want something changed, put in a ticket on the GitHub repository. +#item,id,metadata +stone,1,0 +sstone,1,0 +smoothstone,1,0 +rock,1,0 +granite,1,1 +gstone,1,1 +polishedgranite,1,2 +pgranite,1,2 +pgstone,1,2 +polishedgstone,1,2 +diorite,1,3 +dstone,1,3 +polisheddiorite,1,4 +pdiorite,1,4 +pdstone,1,4 +polisheddstone,1,4 +andesite,1,5 +astone,1,5 +polishedandesite,1,6 +pandesite,1,6 +pastone,1,6 +grass,2,0 +greendirt,2,0 +greenearth,2,0 +greenland,2,0 +dirt,3,0 +earth,3,0 +land,3,0 +cdirt,3,1 +grasslessdirt,3,1 +grasslessearth,3,1 +grasslessland,3,1 +coarsedirt,3,1 +coarseland,3,1 +coarseearth,3,1 +podzol,3,2 +cobblestone,4,0 +cstone,4,0 +cobble,4,0 +wood,5,0 +plank,5,0 +woodenplank,5,0 +woodplank,5,0 +wplank,5,0 +plankwooden,5,0 +plankwood,5,0 +plankw,5,0 +oakplank,5,0 +oakwoodenplank,5,0 +oakwoodplank,5,0 +oakwplank,5,0 +oakplankwooden,5,0 +oakplankwood,5,0 +oakplankw,5,0 +oplank,5,0 +owoodenplank,5,0 +owoodplank,5,0 +owplank,5,0 +oplankwooden,5,0 +oplankwood,5,0 +oplankw,5,0 +pineplank,5,1 +pinewoodenplank,5,1 +pinewoodplank,5,1 +pinewplank,5,1 +pineplankwooden,5,1 +pineplankwood,5,1 +pineplankw,5,1 +pplank,5,1 +pwoodenplank,5,1 +pwoodplank,5,1 +pwplank,5,1 +pplankwooden,5,1 +pplankwood,5,1 +pplankw,5,1 +darkplank,5,1 +darkwoodenplank,5,1 +darkwoodplank,5,1 +darkwplank,5,1 +darkplankwooden,5,1 +darkplankwood,5,1 +darkplankw,5,1 +dplank,5,1 +dwoodenplank,5,1 +dwoodplank,5,1 +dwplank,5,1 +dplankwooden,5,1 +dplankwood,5,1 +dplankw,5,1 +spruceplank,5,1 +sprucewoodenplank,5,1 +sprucewoodplank,5,1 +sprucewplank,5,1 +spruceplankwooden,5,1 +spruceplankwood,5,1 +spruceplankw,5,1 +splank,5,1 +swoodenplank,5,1 +swoodplank,5,1 +swplank,5,1 +splankwooden,5,1 +splankwood,5,1 +splankw,5,1 +birchplank,5,2 +birchwoodenplank,5,2 +birchwoodplank,5,2 +birchwplank,5,2 +birchplankwooden,5,2 +birchplankwood,5,2 +birchplankw,5,2 +bplank,5,2 +bwoodenplank,5,2 +bwoodplank,5,2 +bwplank,5,2 +bplankwooden,5,2 +bplankwood,5,2 +bplankw,5,2 +lightplank,5,2 +lightwoodenplank,5,2 +lightwoodplank,5,2 +lightwplank,5,2 +lightplankwooden,5,2 +lightplankwood,5,2 +lightplankw,5,2 +lplank,5,2 +lwoodenplank,5,2 +lwoodplank,5,2 +lwplank,5,2 +lplankwooden,5,2 +lplankwood,5,2 +lplankw,5,2 +whiteplank,5,2 +whitewoodenplank,5,2 +whitewoodplank,5,2 +whitewplank,5,2 +whiteplankwooden,5,2 +whiteplankwood,5,2 +whiteplankw,5,2 +wwoodenplank,5,2 +wwoodplank,5,2 +wwplank,5,2 +wplankwooden,5,2 +wplankwood,5,2 +wplankw,5,2 +jungleplank,5,3 +junglewoodenplank,5,3 +junglewoodplank,5,3 +junglewplank,5,3 +jungleplankwooden,5,3 +jungleplankwood,5,3 +jungleplankw,5,3 +jplank,5,3 +jwoodenplank,5,3 +jwoodplank,5,3 +jwplank,5,3 +jplankwooden,5,3 +jplankwood,5,3 +jplankw,5,3 +forestplank,5,3 +forestwoodenplank,5,3 +forestwoodplank,5,3 +forestwplank,5,3 +forestplankwooden,5,3 +forestplankwood,5,3 +forestplankw,5,3 +fplank,5,3 +fwoodenplank,5,3 +fwoodplank,5,3 +fwplank,5,3 +fplankwooden,5,3 +fplankwood,5,3 +fplankw,5,3 +acaciaplank,5,4 +acaciawoodenplank,5,4 +acaciawoodplank,5,4 +acaciawplank,5,4 +acaciaplankwooden,5,4 +acaciaplankwood,5,4 +acaciaplankw,5,4 +aplank,5,4 +awoodenplank,5,4 +awoodplank,5,4 +awplank,5,4 +aplankwooden,5,4 +aplankwood,5,4 +aplankw,5,4 +darkoakplank,5,5 +darkoakwoodenplank,5,5 +darkoakwoodplank,5,5 +darkoakwplank,5,5 +darkoakplankwooden,5,5 +darkoakplankwood,5,5 +darkoakplankw,5,5 +doakplank,5,5 +doakwoodenplank,5,5 +doakwoodplank,5,5 +doakwplank,5,5 +doakplankwooden,5,5 +doakplankwood,5,5 +doakplankw,5,5 +doplank,5,5 +dowoodenplank,5,5 +dowoodplank,5,5 +dowplank,5,5 +doplankwooden,5,5 +doplankwood,5,5 +doplankw,5,5 +sapling,6,0 +treesapling,6,0 +logsapling,6,0 +trunksapling,6,0 +woodsapling,6,0 +oaktreesapling,6,0 +oaklogsapling,6,0 +oaktrunksapling,6,0 +oakwoodsapling,6,0 +osapling,6,0 +otreesapling,6,0 +ologsapling,6,0 +otrunksapling,6,0 +owoodsapling,6,0 +darksapling,6,1 +darktreesapling,6,1 +darklogsapling,6,1 +darktrunksapling,6,1 +darkwoodsapling,6,1 +sprucesapling,6,1 +sprucetreesapling,6,1 +sprucelogsapling,6,1 +sprucetrunksapling,6,1 +sprucewoodsapling,6,1 +pinesapling,6,1 +pinetreesapling,6,1 +pinelogsapling,6,1 +pinetrunksapling,6,1 +pinewoodsapling,6,1 +dsapling,6,1 +dtreesapling,6,1 +dlogsapling,6,1 +dtrunksapling,6,1 +dwoodsapling,6,1 +ssapling,6,1 +streesapling,6,1 +slogsapling,6,1 +strunksapling,6,1 +swoodsapling,6,1 +psapling,6,1 +ptreesapling,6,1 +plogsapling,6,1 +ptrunksapling,6,1 +pwoodsapling,6,1 +birchsapling,6,2 +birchtreesapling,6,2 +birchlogsapling,6,2 +birchtrunksapling,6,2 +birchwoodsapling,6,2 +lightsapling,6,2 +lighttreesapling,6,2 +lightlogsapling,6,2 +lighttrunksapling,6,2 +lightwoodsapling,6,2 +whitesapling,6,2 +whitetreesapling,6,2 +whitelogsapling,6,2 +whitetrunksapling,6,2 +whitewoodsapling,6,2 +bsapling,6,2 +btreesapling,6,2 +blogsapling,6,2 +btrunksapling,6,2 +bwoodsapling,6,2 +lsapling,6,2 +ltreesapling,6,2 +llogsapling,6,2 +ltrunksapling,6,2 +lwoodsapling,6,2 +wsapling,6,2 +wtreesapling,6,2 +wlogsapling,6,2 +wtrunksapling,6,2 +wwoodsapling,6,2 +junglesapling,6,3 +jungletreesapling,6,3 +junglelogsapling,6,3 +jungletrunksapling,6,3 +junglewoodsapling,6,3 +forestsapling,6,3 +foresttreesapling,6,3 +forestlogsapling,6,3 +foresttrunksapling,6,3 +forestwoodsapling,6,3 +jsapling,6,3 +jtreesapling,6,3 +jlogsapling,6,3 +jtrunksapling,6,3 +jwoodsapling,6,3 +fsapling,6,3 +ftreesapling,6,3 +flogsapling,6,3 +ftrunksapling,6,3 +fwoodsapling,6,3 +acaciasapling,6,4 +acaciatreesapling,6,4 +acacialogsapling,6,4 +acaciatrunksapling,6,4 +acaciawoodsapling,6,4 +asapling,6,4 +atreesapling,6,4 +alogsapling,6,4 +atrunksapling,6,4 +awoodsapling,6,4 +darkoaksapling,6,5 +darkoaktreesapling,6,5 +darkoaklogsapling,6,5 +darkoaktrunksapling,6,5 +darkoakwoodsapling,6,5 +doaksapling,6,5 +doaktreesapling,6,5 +doaklogsapling,6,5 +doaktrunksapling,6,5 +dosapling,6,5 +dowoodsapling,6,5 +dotreesapling,6,5 +dologsapling,6,5 +dotrunksapling,6,5 +bedrock,7,0 +oprock,7,0 +opblock,7,0 +adminblock,7,0 +adminrock,7,0 +adminium,7,0 +water,8,0 +stationarywater,9,0 +stillwater,9,0 +swater,9,0 +lava,10,0 +stationarylava,11,0 +stilllava,11,0 +slava,11,0 +sand,12,0 +redsand,12,1 +rsand,12,1 +gravel,13,0 +goldore,14,0 +oregold,14,0 +gore,14,0 +oreg,14,0 +ogold,14,0 +goldo,14,0 +ironore,15,0 +oreiron,15,0 +irono,15,0 +oiron,15,0 +steelore,15,0 +oresteel,15,0 +steelo,15,0 +osteel,15,0 +iore,15,0 +orei,15,0 +sore,15,0 +ores,15,0 +coalore,16,0 +orecoal,16,0 +coalo,16,0 +ocoal,16,0 +core,16,0 +tree,17,0 +log,17,0 +trunk,17,0 +oak,17,0 +oaktree,17,0 +oaklog,17,0 +oaktrunk,17,0 +oakwood,17,0 +otree,17,0 +olog,17,0 +otrunk,17,0 +owood,17,0 +pine,17,1 +pinetree,17,1 +pinelog,17,1 +pinetrunk,17,1 +pinewood,17,1 +darktree,17,1 +darklog,17,1 +darktrunk,17,1 +darkwood,17,1 +spruce,17,1 +sprucetree,17,1 +sprucelog,17,1 +sprucetrunk,17,1 +sprucewood,17,1 +dtree,17,1 +dlog,17,1 +dtrunk,17,1 +dwood,17,1 +stree,17,1 +slog,17,1 +strunk,17,1 +swood,17,1 +ptree,17,1 +plog,17,1 +ptrunk,17,1 +pwood,17,1 +birch,17,2 +birchtree,17,2 +birchlog,17,2 +birchtrunk,17,2 +birchwood,17,2 +whitetree,17,2 +whitelog,17,2 +whitetrunk,17,2 +whitewood,17,2 +lighttree,17,2 +lightlog,17,2 +lighttrunk,17,2 +lightwood,17,2 +btree,17,2 +blog,17,2 +btrunk,17,2 +bwood,17,2 +wtree,17,2 +wlog,17,2 +wtrunk,17,2 +wwood,17,2 +ltree,17,2 +llog,17,2 +ltrunk,17,2 +lwood,17,2 +jungletree,17,3 +junglelog,17,3 +jungletrunk,17,3 +junglewood,17,3 +jungle,17,3 +forest,17,3 +foresttree,17,3 +forestlog,17,3 +foresttrunk,17,3 +forestwood,17,3 +jtree,17,3 +jlog,17,3 +jtrunk,17,3 +jwood,17,3 +ftree,17,3 +flog,17,3 +ftrunk,17,3 +fwood,17,3 +leaves,18,0 +leaf,18,0 +treeleaves,18,0 +logleaves,18,0 +trunkleaves,18,0 +woodleaves,18,0 +oakleaves,18,0 +oakleaf,18,0 +oleaves,18,0 +oleaf,18,0 +oaktreeleaves,18,0 +oaklogleaves,18,0 +oaktrunkleaves,18,0 +oakwoodleaves,18,0 +otreeleaves,18,0 +ologleaves,18,0 +otrunkleaves,18,0 +owoodleaves,18,0 +treeleaf,18,0 +logleaf,18,0 +trunkleaf,18,0 +woodleaf,18,0 +oaktreeleaf,18,0 +oaklogleaf,18,0 +oaktrunkleaf,18,0 +oakwoodleaf,18,0 +otreeleaf,18,0 +ologleaf,18,0 +otrunkleaf,18,0 +owoodleaf,18,0 +pineleaves,18,1 +pineleaf,18,1 +pleaves,18,1 +pleaf,18,1 +pinetreeleaves,18,1 +pinelogleaves,18,1 +pinetrunkleaves,18,1 +pinewoodleaves,18,1 +ptreeleaves,18,1 +plogleaves,18,1 +ptrunkleaves,18,1 +pwoodleaves,18,1 +spruceleaves,18,1 +spruceleaf,18,1 +sleaves,18,1 +sleaf,18,1 +sprucetreeleaves,18,1 +sprucelogleaves,18,1 +sprucetrunkleaves,18,1 +sprucewoodleaves,18,1 +streeleaves,18,1 +slogleaves,18,1 +strunkleaves,18,1 +swoodleaves,18,1 +darkleaves,18,1 +darkleaf,18,1 +dleaves,18,1 +dleaf,18,1 +darktreeleaves,18,1 +darklogleaves,18,1 +darktrunkleaves,18,1 +darkwoodleaves,18,1 +dtreeleaves,18,1 +dlogleaves,18,1 +dtrunkleaves,18,1 +dwoodleaves,18,1 +sprucetreeleaf,18,1 +sprucelogleaf,18,1 +sprucetrunkleaf,18,1 +sprucewoodleaf,18,1 +streeleaf,18,1 +slogleaf,18,1 +strunkleaf,18,1 +swoodleaf,18,1 +pinetreeleaf,18,1 +pinelogleaf,18,1 +pinetrunkleaf,18,1 +pinewoodleaf,18,1 +ptreeleaf,18,1 +plogleaf,18,1 +ptrunkleaf,18,1 +pwoodleaf,18,1 +darktreeleaf,18,1 +darklogleaf,18,1 +darktrunkleaf,18,1 +darkwoodleaf,18,1 +dtreeleaf,18,1 +dlogleaf,18,1 +dtrunkleaf,18,1 +dwoodleaf,18,1 +birchleaves,18,2 +birchleaf,18,2 +bleaves,18,2 +bleaf,18,2 +birchtreeleaves,18,2 +birchlogleaves,18,2 +birchtrunkleaves,18,2 +birchwoodleaves,18,2 +btreeleaves,18,2 +blogleaves,18,2 +btrunkleaves,18,2 +bwoodleaves,18,2 +lightleaves,18,2 +lightleaf,18,2 +lleaves,18,2 +lleaf,18,2 +lighttreeleaves,18,2 +lightlogleaves,18,2 +lighttrunkleaves,18,2 +lightwoodleaves,18,2 +ltreeleaves,18,2 +llogleaves,18,2 +ltrunkleaves,18,2 +lwoodleaves,18,2 +whiteleaves,18,2 +whiteleaf,18,2 +wleaves,18,2 +wleaf,18,2 +whitetreeleaves,18,2 +whitelogleaves,18,2 +whitetrunkleaves,18,2 +whitewoodleaves,18,2 +wtreeleaves,18,2 +wlogleaves,18,2 +wtrunkleaves,18,2 +wwoodleaves,18,2 +birchtreeleaf,18,2 +birchlogleaf,18,2 +birchtrunkleaf,18,2 +birchwoodleaf,18,2 +btreeleaf,18,2 +blogleaf,18,2 +btrunkleaf,18,2 +bwoodleaf,18,2 +lighttreeleaf,18,2 +lightlogleaf,18,2 +lighttrunkleaf,18,2 +lightwoodleaf,18,2 +ltreeleaf,18,2 +llogleaf,18,2 +ltrunkleaf,18,2 +lwoodleaf,18,2 +whitetreeleaf,18,2 +whitelogleaf,18,2 +whitetrunkleaf,18,2 +whitewoodleaf,18,2 +wtreeleaf,18,2 +wlogleaf,18,2 +wtrunkleaf,18,2 +wwoodleaf,18,2 +jungleleaves,18,3 +jungleleaf,18,3 +jleaves,18,3 +jleaf,18,3 +jungletreeleaves,18,3 +junglelogleaves,18,3 +jungletrunkleaves,18,3 +junglewoodleaves,18,3 +jtreeleaves,18,3 +jlogleaves,18,3 +jtrunkleaves,18,3 +jwoodleaves,18,3 +forestleaves,18,3 +forestleaf,18,3 +fleaves,18,3 +fleaf,18,3 +foresttreeleaves,18,3 +forestlogleaves,18,3 +foresttrunkleaves,18,3 +forestwoodleaves,18,3 +ftreeleaves,18,3 +flogleaves,18,3 +ftrunkleaves,18,3 +fwoodleaves,18,3 +jungletreeleaf,18,3 +junglelogleaf,18,3 +jungletrunkleaf,18,3 +junglewoodleaf,18,3 +jtreeleaf,18,3 +jlogleaf,18,3 +jtrunkleaf,18,3 +jwoodleaf,18,3 +foresttreeleaf,18,3 +forestlogleaf,18,3 +foresttrunkleaf,18,3 +forestwoodleaf,18,3 +ftreeleaf,18,3 +flogleaf,18,3 +ftrunkleaf,18,3 +fwoodleaf,18,3 +sponge,19,0 +wetsponge,19,1 +glass,20,0 +blockglass,20,0 +glassblock,20,0 +lapislazuliore,21,0 +lapislazulio,21,0 +orelapislazuli,21,0 +olapislazuli,21,0 +lapisore,21,0 +lapiso,21,0 +orelapis,21,0 +olapis,21,0 +lore,21,0 +orel,21,0 +lapislazuliblock,22,0 +blocklapislazuli,22,0 +lapisblock,22,0 +blocklapis,22,0 +lblock,22,0 +blockl,22,0 +dispenser,23,0 +dispense,23,0 +sandstone,24,0 +sastone,24,0 +cpstone,24,1 +creepersandstone,24,1 +creepersastone,24,1 +creepsandstone,24,1 +creepsastone,24,1 +csandstone,24,1 +csastone,24,1 +hieroglyphicsandstone,24,1 +hieroglyphicsastone,24,1 +hieroglyphsandstone,24,1 +hieroglyphsastone,24,1 +hsandstone,24,1 +hsastone,24,1 +pyramidsandstone,24,1 +pyramidsastone,24,1 +psandstone,24,1 +psastone,24,1 +chiseledsandstone,24,1 +chiseledsastone,24,1 +chiselsandstone,24,1 +chiselsastone,24,1 +smstone,24,2 +smoothsandstone,24,2 +smoothsastone,24,2 +ssandstone,24,2 +smsastone,24,2 +ssastone,24,2 +noteblock,25,0 +musicblock,25,0 +nblock,25,0 +mblock,25,0 +poweredtrack,27,0 +poweredrails,27,0 +poweredrail,27,0 +boostertrack,27,0 +boosterrails,27,0 +boosterrail,27,0 +powertrack,27,0 +powerrails,27,0 +powerrail,27,0 +boosttrack,27,0 +boostrails,27,0 +boostrail,27,0 +ptrack,27,0 +prails,27,0 +prail,27,0 +btrack,27,0 +brails,27,0 +brail,27,0 +detectortrack,28,0 +detectorrails,28,0 +detectorrail,28,0 +detectingtrack,28,0 +detectingrails,28,0 +detectingrail,28,0 +detecttrack,28,0 +detectrails,28,0 +detectrail,28,0 +dtrack,28,0 +drails,28,0 +drail,28,0 +stickypistonbase,29,0 +stickypiston,29,0 +stickpistonbase,29,0 +stickpiston,29,0 +stickyp,29,0 +spistonbase,29,0 +spiston,29,0 +pistonstickybase,29,0 +pistonsticky,29,0 +pistonstickbase,29,0 +pistonstick,29,0 +pistonsbase,29,0 +pistons,29,0 +psticky,29,0 +pstick,29,0 +spiderweb,30,0 +cobweb,30,0 +sweb,30,0 +cweb,30,0 +web,30,0 +longgrass,31,1 +tallgrass,31,1 +wildgrass,31,1 +grasslong,31,1 +grasstall,31,1 +grasswild,31,1 +lgrass,31,1 +tgrass,31,1 +wgrass,31,1 +fern,31,2 +bush,31,2 +deadshrub,32,0 +dshrub,32,0 +deadbush,32,0 +dbush,32,0 +deadsapling,32,0 +piston,33,0 +pistonbase,33,0 +pistonblock,33,0 +whitewool,35,0 +whitecloth,35,0 +whitecotton,35,0 +wcloth,35,0 +wwool,35,0 +wcotton,35,0 +cloth,35,0 +wool,35,0 +cotton,35,0 +orangewool,35,1 +orangecloth,35,1 +orangecotton,35,1 +ocloth,35,1 +owool,35,1 +ocotton,35,1 +magentawool,35,2 +magentacloth,35,2 +magentacotton,35,2 +mcloth,35,2 +mwool,35,2 +mcotton,35,2 +lightbluewool,35,3 +lightbluecloth,35,3 +lightbluecotton,35,3 +lbluecloth,35,3 +lbluewool,35,3 +lbluecotton,35,3 +lightblucloth,35,3 +lightbluwool,35,3 +lightblucotton,35,3 +lblucloth,35,3 +lbluwool,35,3 +lblucotton,35,3 +lbcloth,35,3 +lbwool,35,3 +lbcotton,35,3 +yellowwool,35,4 +yellowcloth,35,4 +yellowcotton,35,4 +ycloth,35,4 +ywool,35,4 +ycotton,35,4 +lightgreenwool,35,5 +lightgreencloth,35,5 +lightgreencotton,35,5 +lgreencloth,35,5 +lgreenwool,35,5 +lgreencotton,35,5 +lightgrecloth,35,5 +lightgrewool,35,5 +lightgrecotton,35,5 +lgrecloth,35,5 +lgrewool,35,5 +lgrecotton,35,5 +limecloth,35,5 +limewool,35,5 +limecotton,35,5 +lcloth,35,5 +lwool,35,5 +lcotton,35,5 +pinkwool,35,6 +pinkcloth,35,6 +pinkcotton,35,6 +picloth,35,6 +piwool,35,6 +picotton,35,6 +darkgraywool,35,7 +darkgraycloth,35,7 +darkgraycotton,35,7 +darkgreywool,35,7 +darkgreycloth,35,7 +darkgreycotton,35,7 +dgraycloth,35,7 +dgraywool,35,7 +dgraycotton,35,7 +dgreycloth,35,7 +dgreywool,35,7 +dgreycotton,35,7 +darkgracloth,35,7 +darkgrawool,35,7 +darkgracotton,35,7 +dgracloth,35,7 +dgrawool,35,7 +dgracotton,35,7 +graycloth,35,7 +graywool,35,7 +graycotton,35,7 +greycloth,35,7 +greywool,35,7 +greycotton,35,7 +gracloth,35,7 +grawool,35,7 +gracotton,35,7 +lgwool,35,8 +lightgraywool,35,8 +lightgraycloth,35,8 +lightgraycotton,35,8 +lgraycloth,35,8 +lgraywool,35,8 +lgraycotton,35,8 +lightgreywool,35,8 +lightgreycloth,35,8 +lightgreycotton,35,8 +lgreycloth,35,8 +lgreywool,35,8 +lgreycotton,35,8 +lightgracloth,35,8 +lightgrawool,35,8 +lightgracotton,35,8 +lgracloth,35,8 +lgrawool,35,8 +lgracotton,35,8 +silvercloth,35,8 +silverwool,35,8 +silvercotton,35,8 +sicloth,35,8 +siawool,35,8 +siacotton,35,8 +cyanwool,35,9 +cyancloth,35,9 +cyancotton,35,9 +ccloth,35,9 +cwool,35,9 +ccotton,35,9 +purplewool,35,10 +purplecloth,35,10 +purplecotton,35,10 +pucloth,35,10 +puwool,35,10 +pucotton,35,10 +bluewool,35,11 +bluecloth,35,11 +bluecotton,35,11 +blucloth,35,11 +bluwool,35,11 +blucotton,35,11 +brownwool,35,12 +browncloth,35,12 +browncotton,35,12 +brocloth,35,12 +browool,35,12 +brocotton,35,12 +darkgreenwool,35,13 +darkgreencloth,35,13 +darkgreencotton,35,13 +dgreencloth,35,13 +dgreenwool,35,13 +dgreencotton,35,13 +greencloth,35,13 +greenwool,35,13 +greencotton,35,13 +darkgrecloth,35,13 +darkgrewool,35,13 +darkgrecotton,35,13 +dgrecloth,35,13 +dgrewool,35,13 +dgrecotton,35,13 +grecloth,35,13 +grewool,35,13 +grecotton,35,13 +redwool,35,14 +redcloth,35,14 +redcotton,35,14 +rcloth,35,14 +rwool,35,14 +rcotton,35,14 +blackwool,35,15 +blackcloth,35,15 +blackcotton,35,15 +blacloth,35,15 +blawool,35,15 +blacotton,35,15 +dandelion,37,0 +yellowdandelion,37,0 +ydandelion,37,0 +yellowflower,37,0 +yflower,37,0 +flower,37,0 +rose,38,0 +redrose,38,0 +rrose,38,0 +redflower,38,0 +rflower,38,0 +poppy,38,0 +redpoppy,38,0 +blueorchid,38,1 +cyanorchid,38,1 +lightblueorchid,38,1 +lblueorchid,38,1 +orchid,38,1 +allium,38,2 +magentaallium,38,2 +azurebluet,38,3 +whiteazurebluet,38,3 +abluet,38,3 +azureb,38,3 +houstonia,38,3 +redtulip,38,4 +tulipred,38,4 +rtulip,38,4 +tulipr,38,4 +orangetulip,38,5 +tuliporange,38,5 +otulip,38,5 +tulipo,38,5 +whitetulip,38,6 +tulipwhite,38,6 +wtulip,38,6 +tulipw,38,6 +pinktulip,38,7 +tulippink,38,7 +ptulip,38,7 +tulipp,38,7 +oxeye,38,8 +daisy,38,8 +oxeyedaisy,38,8 +daisyoxeye,38,8 +moondaisy,38,8 +daisymoon,38,8 +lightgrayoxeye,38,8 +lgrayoxeye,38,8 +lightgreyoxeye,38,8 +lgreyoxeye,38,8 +brownmushroom,39,0 +brownshroom,39,0 +brownmush,39,0 +bmushroom,39,0 +bshroom,39,0 +bmush,39,0 +redmushroom,40,0 +redshroom,40,0 +redmush,40,0 +rmushroom,40,0 +rshroom,40,0 +rmush,40,0 +goldblock,41,0 +blockgold,41,0 +gblock,41,0 +blockg,41,0 +ironblock,42,0 +steelblock,42,0 +blockiron,42,0 +blocksteel,42,0 +iblock,42,0 +stblock,42,0 +blocki,42,0 +blockst,42,0 +stonedoublestep,43,0 +stonedstep,43,0 +sdoublestep,43,0 +sdstep,43,0 +doublestonestep,43,0 +dstonestep,43,0 +doublesstep,43,0 +doublestep,43,0 +dstep,43,0 +stonedoubleslab,43,0 +stonedslab,43,0 +sdoubleslab,43,0 +sdslab,43,0 +doublestoneslab,43,0 +doublestoneslab2,181,0 +dstoneslab,43,0 +doublesslab,43,0 +doubleslab,43,0 +dslab,43,0 +stonedoublehalfblock,43,0 +stonedhalfblock,43,0 +sdoublehalfblock,43,0 +sdhalfblock,43,0 +doublestonehalfblock,43,0 +dstonehalfblock,43,0 +doubleshalfblock,43,0 +doublehalfblock,43,0 +dhalfblock,43,0 +sandstonedoublestep,43,1 +sandstonedstep,43,1 +sstonedoublestep,43,1 +sstonedstep,43,1 +ssdoublestep,43,1 +ssdstep,43,1 +doublesandstonestep,43,1 +dsandstonestep,43,1 +doublesstonestep,43,1 +dsstonestep,43,1 +doublessstep,43,1 +dsstep,43,1 +sandstonedoubleslab,43,1 +sandstonedslab,43,1 +sstonedoubleslab,43,1 +sstonedslab,43,1 +ssdoubleslab,43,1 +ssdslab,43,1 +doublesandstoneslab,43,1 +dsandstoneslab,43,1 +doublesstoneslab,43,1 +dsstoneslab,43,1 +doublessslab,43,1 +dsslab,43,1 +sandstonedoublehalfblock,43,1 +sandstonedhalfblock,43,1 +sstonedoublehalfblock,43,1 +sstonedhalfblock,43,1 +ssdoublehalfblock,43,1 +ssdhalfblock,43,1 +doublesandstonehalfblock,43,1 +dsandstonehalfblock,43,1 +doublesstonehalfblock,43,1 +dsstonehalfblock,43,1 +doublesshalfblock,43,1 +dsshalfblock,43,1 +plankstonedoublestep,43,2 +woodenstonedoublestep,43,2 +woodenstonedstep,43,2 +woodstonedoublestep,43,2 +woodstonedstep,43,2 +wstonedoublestep,43,2 +wstonedstep,43,2 +doublewoodenstonestep,43,2 +dwoodenstonestep,43,2 +doublewoodstonestep,43,2 +dwoodstonestep,43,2 +doublewstonestep,43,2 +dwstonestep,43,2 +woodenstonedoubleslab,43,2 +woodenstonedslab,43,2 +woodstonedoubleslab,43,2 +woodstonedslab,43,2 +wstonedoubleslab,43,2 +wstonedslab,43,2 +doublewoodenstoneslab,43,2 +dwoodenstoneslab,43,2 +doublewoodstoneslab,43,2 +dwoodstoneslab,43,2 +doublewstoneslab,43,2 +dwstoneslab,43,2 +woodenstonedoublehalfblock,43,2 +woodenstonedhalfblock,43,2 +woodstonedoublehalfblock,43,2 +woodstonedhalfblock,43,2 +wstonedoublehalfblock,43,2 +wstonedhalfblock,43,2 +doublewoodenstonehalfblock,43,2 +dwoodenstonehalfblock,43,2 +doublewoodstonehalfblock,43,2 +dwoodstonehalfblock,43,2 +doublewstonehalfblock,43,2 +dwstonehalfblock,43,2 +cobblestonedoublestep,43,3 +cobblestonedstep,43,3 +cobbledoublestep,43,3 +cobbledstep,43,3 +cstonedoublestep,43,3 +cstonedstep,43,3 +csdoublestep,43,3 +csdstep,43,3 +doublecobblestonestep,43,3 +dcobblestonestep,43,3 +doublecobblestep,43,3 +dcobblestep,43,3 +doublecstonestep,43,3 +dcstonestep,43,3 +doublecsstep,43,3 +dcsstep,43,3 +cobblestonedoubleslab,43,3 +cobblestonedslab,43,3 +cobbledoubleslab,43,3 +cobbledslab,43,3 +cstonedoubleslab,43,3 +cstonedslab,43,3 +csdoubleslab,43,3 +csdslab,43,3 +doublecobblestoneslab,43,3 +dcobblestoneslab,43,3 +doublecobbleslab,43,3 +dcobbleslab,43,3 +doublecstoneslab,43,3 +dcstoneslab,43,3 +doublecsslab,43,3 +dcsslab,43,3 +cobblestonedoublehalfblock,43,3 +cobblestonedhalfblock,43,3 +cobbledoublehalfblock,43,3 +cobbledhalfblock,43,3 +cstonedoublehalfblock,43,3 +cstonedhalfblock,43,3 +csdoublehalfblock,43,3 +csdhalfblock,43,3 +doublecobblestonehalfblock,43,3 +dcobblestonehalfblock,43,3 +doublecobblehalfblock,43,3 +dcobblehalfblock,43,3 +doublecstonehalfblock,43,3 +dcstonehalfblock,43,3 +doublecshalfblock,43,3 +dcshalfblock,43,3 +brickdoublestep,43,4 +brickdstep,43,4 +bdoublestep,43,4 +bdstep,43,4 +brickdoubleslab,43,4 +brickdslab,43,4 +bdoubleslab,43,4 +bdslab,43,4 +doublebrickstep,43,4 +dbrickstep,43,4 +doublebstep,43,4 +dbstep,43,4 +doublebrickslab,43,4 +dbrickslab,43,4 +doublebslab,43,4 +dbslab,43,4 +brickdoublehalfblock,43,4 +brickdhalfblock,43,4 +bdoublehalfblock,43,4 +bdhalfblock,43,4 +doublebrickhalfblock,43,4 +dbrickhalfblock,43,4 +doublebhalfblock,43,4 +dbhalfblock,43,4 +stonebrickdoublestep,43,5 +stonebrickdstep,43,5 +stonebdoublestep,43,5 +stonebdstep,43,5 +sbrickdoublestep,43,5 +sbrickdstep,43,5 +sbdoublestep,43,5 +sbdstep,43,5 +stonebrickdoubleslab,43,5 +stonebrickdslab,43,5 +stonebdoubleslab,43,5 +stonebdslab,43,5 +sbrickdoubleslab,43,5 +sbrickdslab,43,5 +sbdoubleslab,43,5 +sbdslab,43,5 +doublestonebrickstep,43,5 +dstonebrickstep,43,5 +doublestonebstep,43,5 +dstonebstep,43,5 +doublesbrickstep,43,5 +dsbrickstep,43,5 +doublesbstep,43,5 +dsbstep,43,5 +doublestonebrickslab,43,5 +dstonebrickslab,43,5 +doublestonebslab,43,5 +dstonebslab,43,5 +doublesbrickslab,43,5 +dsbrickdslab,43,5 +doublesbslab,43,5 +dsbslab,43,5 +stonebrickdoublehalfblock,43,5 +stonebrickdhalfblock,43,5 +stonebdoublehalfblock,43,5 +stonebdhalfblock,43,5 +sbrickdoublehalfblock,43,5 +sbrickdhalfblock,43,5 +sbdoublehalfblock,43,5 +sbdhalfblock,43,5 +doublestonebrickhalfblock,43,5 +dstonebrickhalfblock,43,5 +doublestonebhalfblock,43,5 +dstonebhalfblock,43,5 +doublesbrickhalfblock,43,5 +dsbrickhalfblock,43,5 +doublesbhalfblock,43,5 +dsbhalfblock,43,5 +netherbrickdoubleslab,43,6 +hellbrickdoubleslab,43,6 +nbrickdoubleslab,43,6 +hbrickdoubleslab,43,6 +netherdoubleslab,43,6 +helldoubleslab,43,6 +nbdoubleslab,43,6 +hbdoubleslab,43,6 +hdoubleslab,43,6 +ndoubleslab,43,6 +netherbrickdoublestep,43,6 +hellbrickdoublestep,43,6 +nbrickdoublestep,43,6 +hbrickdoublestep,43,6 +netherdoublestep,43,6 +helldoublestep,43,6 +nbdoublestep,43,6 +hbdoublestep,43,6 +ndoublestep,43,6 +hdoublestep,43,6 +netherbrickdoublehalfblock,43,6 +hellbrickdoublehalfblock,43,6 +nbrickdoublehalfblock,43,6 +hbrickdoublehalfblock,43,6 +netherdoublehalfblock,43,6 +helldoublehalfblock,43,6 +nbdoublehalfblock,43,6 +hbdoublehalfblock,43,6 +ndoublehalfblock,43,6 +hdoublehalfblock,43,6 +netherbrickdslab,43,6 +hellbrickdslab,43,6 +nbrickdslab,43,6 +hbrickdslab,43,6 +netherdslab,43,6 +helldslab,43,6 +nbdslab,43,6 +hbdslab,43,6 +hdslab,43,6 +ndslab,43,6 +netherbrickdstep,43,6 +hellbrickdstep,43,6 +nbrickdstep,43,6 +hbrickdstep,43,6 +netherdstep,43,6 +helldstep,43,6 +nbdstep,43,6 +hbdstep,43,6 +ndstep,43,6 +hdstep,43,6 +netherbrickdhalfblock,43,6 +hellbrickdhalfblock,43,6 +nbrickdhalfblock,43,6 +hbrickdhalfblock,43,6 +netherdhalfblock,43,6 +helldhalfblock,43,6 +nbdhalfblock,43,6 +hbdhalfblock,43,6 +ndhalfblock,43,6 +hdhalfblock,43,6 +doublenetherbrickslab,43,6 +doublehellbrickslab,43,6 +doublenbrickslab,43,6 +doublehbrickslab,43,6 +doublenetherslab,43,6 +doublehellslab,43,6 +doublenbslab,43,6 +doublehbslab,43,6 +doublehslab,43,6 +doublenslab,43,6 +doublenetherbrickstep,43,6 +doublehellbrickstep,43,6 +doublenbrickstep,43,6 +doublehbrickstep,43,6 +doublenetherstep,43,6 +doublehellstep,43,6 +doublenbstep,43,6 +doublehbstep,43,6 +doublenstep,43,6 +doublehstep,43,6 +doublenetherbrickhalfblock,43,6 +doublehellbrickhalfblock,43,6 +doublenbrickhalfblock,43,6 +doublehbrickhalfblock,43,6 +doublenetherhalfblock,43,6 +doublehellhalfblock,43,6 +doublenbhalfblock,43,6 +doublehbhalfblock,43,6 +doublenhalfblock,43,6 +doublehhalfblock,43,6 +dnetherbrickslab,43,6 +dhellbrickslab,43,6 +dnbrickslab,43,6 +dhbrickslab,43,6 +dnetherslab,43,6 +dhellslab,43,6 +dnbslab,43,6 +dhbslab,43,6 +dhslab,43,6 +dnslab,43,6 +dnetherbrickstep,43,6 +dhellbrickstep,43,6 +dnbrickstep,43,6 +dhbrickstep,43,6 +dnetherstep,43,6 +dhellstep,43,6 +dnbstep,43,6 +dhbstep,43,6 +dnstep,43,6 +dhstep,43,6 +dnetherbrickhalfblock,43,6 +dhellbrickhalfblock,43,6 +dnbrickhalfblock,43,6 +dhbrickhalfblock,43,6 +dnetherhalfblock,43,6 +dhellhalfblock,43,6 +dnbhalfblock,43,6 +dhbhalfblock,43,6 +dnhalfblock,43,6 +dhhalfblock,43,6 +netherquartzdoublestep,43,7 +hellquartzdoublestep,43,7 +deathquartzdoublestep,43,7 +nquartzdoublestep,43,7 +hquartzdoublestep,43,7 +dquartzdoublestep,43,7 +quartzdoublestep,43,7 +nqdoublestep,43,7 +hqdoublestep,43,7 +dqdoublestep,43,7 +qdoublestep,43,7 +netherquartzdoubleslab,43,7 +hellquartzdoubleslab,43,7 +deathquartzdoubleslab,43,7 +nquartzdoubleslab,43,7 +hquartzdoubleslab,43,7 +dquartzdoubleslab,43,7 +quartzdoubleslab,43,7 +nqdoubleslab,43,7 +hqdoubleslab,43,7 +dqdoubleslab,43,7 +qdoubleslab,43,7 +netherquartzdoublehalfblock,43,7 +hellquartzdoublehalfblock,43,7 +deathquartzdoublehalfblock,43,7 +nquartzdoublehalfblock,43,7 +hquartzdoublehalfblock,43,7 +dquartzdoublehalfblock,43,7 +quartzdoublehalfblock,43,7 +nqdoublehalfblock,43,7 +hqdoublehalfblock,43,7 +dqdoublehalfblock,43,7 +qdoublehalfblock,43,7 +netherquartzdslab,43,7 +hellquartzdslab,43,7 +deathquartzdslab,43,7 +nquartzdslab,43,7 +hquartzdslab,43,7 +dquartzdslab,43,7 +quartzdslab,43,7 +nqdslab,43,7 +hqdslab,43,7 +dqdslab,43,7 +qdslab,43,7 +netherquartzdstep,43,7 +hellquartzdstep,43,7 +deathquartzdstep,43,7 +nquartzdstep,43,7 +hquartzdstep,43,7 +dquartzdstep,43,7 +quartzdstep,43,7 +nqdstep,43,7 +hqdstep,43,7 +dqdstep,43,7 +qdstep,43,7 +netherquartzdhalfblock,43,7 +hellquartzdhalfblock,43,7 +deathquartzdhalfblock,43,7 +nquartzdhalfblock,43,7 +hquartzdhalfblock,43,7 +dquartzdhalfblock,43,7 +quartzdhalfblock,43,7 +nqdhalfblock,43,7 +hqdhalfblock,43,7 +dqdhalfblock,43,7 +qdhalfblock,43,7 +doublenetherquartzslab,43,7 +doublehellquartzslab,43,7 +doubledeathquartzslab,43,7 +doublenquartzslab,43,7 +doublehquartzslab,43,7 +doubledquartzslab,43,7 +doublequartzslab,43,7 +doublenqslab,43,7 +doublehqslab,43,7 +doubledqslab,43,7 +doubleqslab,43,7 +doublenetherquartzstep,43,7 +doublehellquartzstep,43,7 +doubledeathquartzstep,43,7 +doublenquartzstep,43,7 +doublehquartzstep,43,7 +doubledquartzstep,43,7 +doublequartzstep,43,7 +doublenqstep,43,7 +doublehqstep,43,7 +doubledqstep,43,7 +doubleqstep,43,7 +doublenetherquartzhalfblock,43,7 +doublehellquartzhalfblock,43,7 +doubledeathquartzhalfblock,43,7 +doublenquartzhalfblock,43,7 +doublehquartzhalfblock,43,7 +doubledquartzhalfblock,43,7 +doublequartzhalfblock,43,7 +doublenqhalfblock,43,7 +doublehqhalfblock,43,7 +doubledqhalfblock,43,7 +doubleqhalfblock,43,7 +dnetherquartzslab,43,7 +dhellquartzslab,43,7 +ddeathquartzslab,43,7 +dnquartzslab,43,7 +dhquartzslab,43,7 +ddquartzslab,43,7 +dnqslab,43,7 +dhqslab,43,7 +ddqslab,43,7 +dnetherquartzstep,43,7 +dhellquartzstep,43,7 +ddeathquartzstep,43,7 +dnquartzstep,43,7 +dhquartzstep,43,7 +ddquartzstep,43,7 +dnqstep,43,7 +dhqstep,43,7 +ddqstep,43,7 +dnetherquartzhalfblock,43,7 +dhellquartzhalfblock,43,7 +ddeathquartzhalfblock,43,7 +dnquartzhalfblock,43,7 +dhquartzhalfblock,43,7 +ddquartzhalfblock,43,7 +dnqhalfblock,43,7 +dhqhalfblock,43,7 +ddqhalfblock,43,7 +smoothstonedoubleslab,43,8 +smoothstonedoublestep,43,8 +smoothstonedoublehalfblock,43,8 +smoothstonedslab,43,8 +smoothstonedstep,43,8 +smoothstonedhalfblock,43,8 +doublesmoothstoneslab,43,8 +doublesmoothstonestep,43,8 +doublesmoothstonehalfblock,43,8 +dsmoothstoneslab,43,8 +dsmoothstonestep,43,8 +dsmoothstonehalfblock,43,8 +smoothsandstonedoubleslab,43,9 +ssandstonedoubleslab,43,9 +ssstonedoubleslab,43,9 +sssdoubleslab,43,9 +smoothsandstonedoublestep,43,9 +ssandstonedoublestep,43,9 +ssstonedoublestep,43,9 +sssdoublestep,43,9 +smoothsandstonedoublehalfblock,43,9 +ssandstonedoublehalfblock,43,9 +ssstonedoublehalfblock,43,9 +sssdoublehalfblock,43,9 +smoothsandstonedslab,43,9 +ssandstonedslab,43,9 +ssstonedslab,43,9 +sssdslab,43,9 +smoothsandstonedstep,43,9 +ssandstonedstep,43,9 +ssstonedstep,43,9 +sssdstep,43,9 +smoothsandstonedhalfblock,43,9 +ssandstonedhalfblock,43,9 +ssstonedhalfblock,43,9 +sssdhalfblock,43,9 +doublesmoothsandstoneslab,43,9 +doublessandstoneslab,43,9 +doublessstoneslab,43,9 +doublesssslab,43,9 +doublesmoothsandstonestep,43,9 +doublessandstonestep,43,9 +doublessstonestep,43,9 +doublesssstep,43,9 +doublesmoothsandstonehalfblock,43,9 +doublessandstonehalfblock,43,9 +doublessstonehalfblock,43,9 +doublessshalfblock,43,9 +dsmoothsandstoneslab,43,9 +dssandstoneslab,43,9 +dssstoneslab,43,9 +dsssslab,43,9 +dsmoothsandstonestep,43,9 +dssandstonestep,43,9 +dssstonestep,43,9 +dsssstep,43,9 +dsmoothsandstonehalfblock,43,9 +dssandstonehalfblock,43,9 +dssstonehalfblock,43,9 +dssshalfblock,43,9 +smoothstonestep,44,0 +stonestep,44,0 +sstep,44,0 +step,44,0 +smoothstoneslab,44,0 +stoneslab,44,0 +stoneslab2,182,0 +sslab,44,0 +slab,44,0 +smoothstonehalfblock,44,0 +stonehalfblock,44,0 +shalfblock,44,0 +halfblock,44,0 +sandstonestep,44,1 +sstonestep,44,1 +ssstep,44,1 +sandstoneslab,44,1 +sstoneslab,44,1 +ssslab,44,1 +sandstonehalfblock,44,1 +sstonehalfblock,44,1 +sshalfblock,44,1 +woodenstonestep,44,2 +woodstonestep,44,2 +wstonestep,44,2 +woodenstoneslab,44,2 +woodstoneslab,44,2 +wstoneslab,44,2 +woodenstonehalfblock,44,2 +woodstonehalfblock,44,2 +wstonehalfblock,44,2 +cobblestonestep,44,3 +cobblestep,44,3 +cstonestep,44,3 +csstep,44,3 +cobblestoneslab,44,3 +cobbleslab,44,3 +cstoneslab,44,3 +csslab,44,3 +cobblestonehalfblock,44,3 +cobblehalfblock,44,3 +cstonehalfblock,44,3 +cshalfblock,44,3 +brickstep,44,4 +bstep,44,4 +brickslab,44,4 +bslab,44,4 +brickhalfblock,44,4 +bhalfblock,44,4 +stonebrickstep,44,5 +stonebstep,44,5 +sbrickstep,44,5 +sbstep,44,5 +stonebrickslab,44,5 +stonebslab,44,5 +sbrickslab,44,5 +sbslab,44,5 +stonebrickhalfblock,44,5 +stonebhalfblock,44,5 +sbrickhalfblock,44,5 +sbhalfblock,44,5 +netherbrickslab,44,6 +hellbrickslab,44,6 +nbrickslab,44,6 +hbrickslab,44,6 +netherslab,44,6 +hellslab,44,6 +nbslab,44,6 +hbslab,44,6 +hslab,44,6 +nslab,44,6 +netherbrickstep,44,6 +hellbrickstep,44,6 +nbrickstep,44,6 +hbrickstep,44,6 +netherstep,44,6 +hellstep,44,6 +nbstep,44,6 +hbstep,44,6 +nstep,44,6 +hstep,44,6 +netherbrickhalfblock,44,6 +hellbrickhalfblock,44,6 +nbrickhalfblock,44,6 +hbrickhalfblock,44,6 +netherhalfblock,44,6 +hellhalfblock,44,6 +nbhalfblock,44,6 +hbhalfblock,44,6 +nhalfblock,44,6 +hhalfblock,44,6 +netherquartzstep,44,7 +hellquartzstep,44,7 +deathquartzstep,44,7 +nquartzstep,44,7 +hquartzstep,44,7 +dquartzstep,44,7 +quartzstep,44,7 +nqstep,44,7 +hqstep,44,7 +dqstep,44,7 +qstep,44,7 +netherquartzslab,44,7 +hellquartzslab,44,7 +deathquartzslab,44,7 +nquartzslab,44,7 +hquartzslab,44,7 +dquartzslab,44,7 +quartzslab,44,7 +nqslab,44,7 +hqslab,44,7 +dqslab,44,7 +qslab,44,7 +netherquartzhalfblock,44,7 +hellquartzhalfblock,44,7 +deathquartzhalfblock,44,7 +nquartzhalfblock,44,7 +hquartzhalfblock,44,7 +dquartzhalfblock,44,7 +quartzhalfblock,44,7 +nqhalfblock,44,7 +hqhalfblock,44,7 +dqhalfblock,44,7 +qhalfblock,44,7 +brickblock,45,0 +blockbrick,45,0 +bblock,45,0 +blockb,45,0 +tnt,46,0 +tntblock,46,0 +blocktnt,46,0 +bombblock,46,0 +blockbomb,46,0 +dynamiteblock,46,0 +blockdynamite,46,0 +bomb,46,0 +dynamite,46,0 +bshelf,47,0 +bookcase,47,0 +casebook,47,0 +bookshelf,47,0 +shelfbook,47,0 +bookblock,47,0 +blockbook,47,0 +mossycobblestone,48,0 +mosscobblestone,48,0 +mcobblestone,48,0 +mossycobble,48,0 +mosscobble,48,0 +mcobble,48,0 +mossstone,48,0 +mossystone,48,0 +mstone,48,0 +obsidian,49,0 +obsi,49,0 +obby,49,0 +torch,50,0 +burningstick,50,0 +burnstick,50,0 +fire,51,0 +flame,51,0 +flames,51,0 +mobspawner,52,0 +mobcage,52,0 +monsterspawner,52,0 +monstercage,52,0 +mspawner,52,0 +mcage,52,0 +spawner,52,0 +cage,52,0 +woodenstairs,53,0 +woodstairs,53,0 +wstairs,53,0 +woodenstair,53,0 +woodstair,53,0 +wstair,53,0 +chest,54,0 +container,54,0 +diamondore,56,0 +crystalore,56,0 +orediamond,56,0 +orecrystal,56,0 +dore,56,0 +ored,56,0 +diamondblock,57,0 +blockdiamond,57,0 +crystalblock,57,0 +blockcrystal,57,0 +dblock,57,0 +blockd,57,0 +workbench,58,0 +craftingbench,58,0 +crafterbench,58,0 +craftbench,58,0 +worktable,58,0 +craftingtable,58,0 +craftertable,58,0 +crafttable,58,0 +wbench,58,0 +cbench,58,0 +soil,60,0 +furnace,61,0 +litfurnace,62,0 +lfurnace,62,0 +burningfurnace,62,0 +burnfurnace,62,0 +bfurnace,62,0 +ladder,65,0 +minecarttrack,66,0 +minecartrails,66,0 +minecartrail,66,0 +mcarttrack,66,0 +mcartrails,66,0 +mcartrail,66,0 +mctrack,66,0 +mcrails,66,0 +mcrail,66,0 +track,66,0 +rails,66,0 +rail,66,0 +cobblestonestairs,67,0 +cstonestairs,67,0 +stonestairs,67,0 +cobblestairs,67,0 +csstairs,67,0 +sstairs,67,0 +cstairs,67,0 +cobblestonestair,67,0 +cstonestair,67,0 +stonestair,67,0 +cobblestair,67,0 +csstair,67,0 +sstair,67,0 +cstair,67,0 +lever,69,0 +stonepressureplate,70,0 +stonepressplate,70,0 +stonepplate,70,0 +stoneplate,70,0 +spressureplate,70,0 +spressplate,70,0 +spplate,70,0 +splate,70,0 +smoothstonepressureplate,70,0 +smoothstonepressplate,70,0 +smoothstonepplate,70,0 +smoothstoneplate,70,0 +sstonepressureplate,70,0 +sstonepressplate,70,0 +sstonepplate,70,0 +sstoneplate,70,0 +woodenpressureplate,72,0 +woodenpressplate,72,0 +woodenpplate,72,0 +woodenplate,72,0 +woodpressureplate,72,0 +woodpressplate,72,0 +woodpplate,72,0 +woodplate,72,0 +wpressureplate,72,0 +wpressplate,72,0 +wpplate,72,0 +wplate,72,0 +redstoneore,73,0 +redsore,73,0 +redore,73,0 +rstoneore,73,0 +rsore,73,0 +rore,73,0 +oreredstone,73,0 +orereds,73,0 +orered,73,0 +orerstone,73,0 +orers,73,0 +orer,73,0 +redstonetorch,76,0 +rstonetorch,76,0 +redstorch,76,0 +redtorch,76,0 +rstorch,76,0 +stonebutton,77,0 +smoothstonebutton,77,0 +sstonebutton,77,0 +sbutton,77,0 +button,77,0 +snowcover,78,0 +snowcovering,78,0 +scover,78,0 +ice,79,0 +frozenwater,79,0 +waterfrozen,79,0 +freezewater,79,0 +waterfreeze,79,0 +snowblock,80,0 +blocksnow,80,0 +sblock,80,0 +blocks,80,0 +cactus,81,0 +cactuses,81,0 +cacti,81,0 +clayblock,82,0 +blockclay,82,0 +cblock,82,0 +blockc,82,0 +jukebox,84,0 +jbox,84,0 +woodenfence,85,0 +fence,85,0 +woodfence,85,0 +wfence,85,0 +fencewooden,85,0 +fencewood,85,0 +fencew,85,0 +oakfence,85,0 +ofence,85,0 +pumpkin,86,0 +netherrack,87,0 +netherrock,87,0 +netherstone,87,0 +hellrack,87,0 +hellrock,87,0 +hellstone,87,0 +deathrack,87,0 +deathrock,87,0 +deathstone,87,0 +nrack,87,0 +nrock,87,0 +nstone,87,0 +hrack,87,0 +hrock,87,0 +hstone,87,0 +drack,87,0 +drock,87,0 +dstone,87,0 +soulsand,88,0 +slowsand,88,0 +slowmud,88,0 +ssand,88,0 +smud,88,0 +mud,88,0 +glowstone,89,0 +glowingstoneblock,89,0 +lightstoneblock,89,0 +glowstoneblock,89,0 +blockglowingstone,89,0 +blocklightstone,89,0 +blockglowstone,89,0 +glowingstone,89,0 +lightstone,89,0 +glowingblock,89,0 +lightblock,89,0 +glowblock,89,0 +lstone,89,0 +gstone,89,0 +portal,90,0 +jackolantern,91,0 +pumpkinlantern,91,0 +glowingpumpkin,91,0 +lightpumpkin,91,0 +jpumpkin,91,0 +plantren,91,0 +glowpumpkin,91,0 +gpumpkin,91,0 +lpumpkin,91,0 +whiteglass,95,0 +whitesglass,95,0 +whitestainedglass,95,0 +wglass,95,0 +wsglass,95,0 +wstainedglass,95,0 +sglass,95,0 +stainedglass,95,0 +orangeglass,95,1 +orangesglass,95,1 +orangestainedglass,95,1 +oglass,95,1 +osglass,95,1 +ostainedglass,95,1 +magentaglass,95,2 +magentasglass,95,2 +magentastainedglass,95,2 +mglass,95,2 +msglass,95,2 +mstainedglass,95,2 +lightblueglass,95,3 +lightbluesglass,95,3 +lightbluestainedglass,95,3 +lblueglass,95,3 +lbluesglass,95,3 +lbluestainedglass,95,3 +lightbluglass,95,3 +lightblusglass,95,3 +lightblustainedglass,95,3 +lbluglass,95,3 +lblusglass,95,3 +lblustainedglass,95,3 +lbglass,95,3 +lbsglass,95,3 +lbstainedglass,95,3 +yellowglass,95,4 +yellowsglass,95,4 +yellowstainedglass,95,4 +yglass,95,4 +ysglass,95,4 +ystainedglass,95,4 +lightgreenglass,95,5 +lightgreensglass,95,5 +lightgreenstainedglass,95,5 +lgreenglass,95,5 +lgreensglass,95,5 +lgreenstainedglass,95,5 +lightgreglass,95,5 +lightgresglass,95,5 +lightgrestainedglass,95,5 +lgreglass,95,5 +lgresglass,95,5 +lgrestainedglass,95,5 +limeglass,95,5 +limesglass,95,5 +limestainedglass,95,5 +lglass,95,5 +lsglass,95,5 +lstainedglass,95,5 +pinkglass,95,6 +pinksglass,95,6 +pinkstainedglass,95,6 +piglass,95,6 +pisglass,95,6 +pistainedglass,95,6 +gyglass,95,7 +darkgrayglass,95,7 +darkgraysglass,95,7 +darkgraystainedglass,95,7 +dgrayglass,95,7 +dgraysglass,95,7 +dgraystainedglass,95,7 +darkgreyglass,95,7 +darkgreysglass,95,7 +darkgreystainedglass,95,7 +dgreyglass,95,7 +dgreysglass,95,7 +dgreystainedglass,95,7 +darkgraglass,95,7 +darkgrasglass,95,7 +darkgrastainedglass,95,7 +dgraglass,95,7 +dgrasglass,95,7 +dgrastainedglass,95,7 +grayglass,95,7 +graysglass,95,7 +graystainedglass,95,7 +greyglass,95,7 +greysglass,95,7 +greystainedglass,95,7 +graglass,95,7 +grasglass,95,7 +grastainedglass,95,7 +lgglass,95,8 +lightgrayglass,95,8 +lightgraysglass,95,8 +lightgraystainedglass,95,8 +lgrayglass,95,8 +lgraysglass,95,8 +lgraystainedglass,95,8 +lightgreyglass,95,8 +lightgreysglass,95,8 +lightgreystainedglass,95,8 +lgreyglass,95,8 +lgreysglass,95,8 +lgreystainedglass,95,8 +lightgraglass,95,8 +lightgrasglass,95,8 +lightgrastainedglass,95,8 +lgraglass,95,8 +lgrasglass,95,8 +lgrastainedglass,95,8 +silverglass,95,8 +silversglass,95,8 +silverstainedglass,95,8 +siglass,95,8 +siasglass,95,8 +siastainedglass,95,8 +cyanglass,95,9 +cyansglass,95,9 +cyanstainedglass,95,9 +cglass,95,9 +csglass,95,9 +cstainedglass,95,9 +purpleglass,95,10 +purplesglass,95,10 +purplestainedglass,95,10 +puglass,95,10 +pusglass,95,10 +pustainedglass,95,10 +blglass,95,11 +blueglass,95,11 +bluesglass,95,11 +bluestainedglass,95,11 +bluglass,95,11 +blusglass,95,11 +blustainedglass,95,11 +brglass,95,12 +brownglass,95,12 +brownsglass,95,12 +brownstainedglass,95,12 +broglass,95,12 +brosglass,95,12 +brostainedglass,95,12 +grglass,95,13 +darkgreenglass,95,13 +darkgreensglass,95,13 +darkgreenstainedglass,95,13 +dgreenglass,95,13 +dgreensglass,95,13 +dgreenstainedglass,95,13 +greenglass,95,13 +greensglass,95,13 +greenstainedglass,95,13 +darkgreglass,95,13 +darkgresglass,95,13 +darkgrestainedglass,95,13 +dgreglass,95,13 +dgresglass,95,13 +dgrestainedglass,95,13 +greglass,95,13 +gresglass,95,13 +grestainedglass,95,13 +redglass,95,14 +redsglass,95,14 +redstainedglass,95,14 +rglass,95,14 +rsglass,95,14 +rstainedglass,95,14 +bkglass,95,15 +blackglass,95,15 +blacksglass,95,15 +blackstainedglass,95,15 +blaglass,95,15 +blasglass,95,15 +blastainedglass,95,15 +trapdoor,96,0 +doortrap,96,0 +hatch,96,0 +tdoor,96,0 +doort,96,0 +trapd,96,0 +dtrap,96,0 +silverfish,97,0 +silverfishsmoothstone,97,0 +silverfishsstone,97,0 +sfishsmoothstone,97,0 +sfishsstone,97,0 +fishsmoothstone,97,0 +fishsstone,97,0 +sfsmoothstone,97,0 +sfsstone,97,0 +trapsmoothstone,97,0 +trapsstone,97,0 +monsteregg,97,0 +monstereggsmoothstone,97,0 +monstereggsstone,97,0 +meggsmoothstone,97,0 +meggsstone,97,0 +mesmoothstone,97,0 +messtone,97,0 +silverfishcobblestone,97,1 +silverfishcstone,97,1 +sfishcobblestone,97,1 +sfishcstone,97,1 +fishcobblestone,97,1 +fishcstone,97,1 +sfcobblestone,97,1 +sfcstone,97,1 +trapcobblestone,97,1 +trapcstone,97,1 +monstereggcobblestone,97,1 +monstereggcstone,97,1 +meggcobblestone,97,1 +meggcstone,97,1 +mecobblestone,97,1 +mecstone,97,1 +silverfishstonebrick,97,2 +silverfishsbrick,97,2 +sfishstonebrick,97,2 +sfishsbrick,97,2 +fishstonebrick,97,2 +fishsbrick,97,2 +sfstonebrick,97,2 +sfsbrick,97,2 +trapstonebrick,97,2 +trapsbrick,97,2 +monstereggstonebrick,97,2 +monstereggsbrick,97,2 +meggstonebrick,97,2 +meggsbrick,97,2 +mestonebrick,97,2 +mesbrick,97,2 +silverfishmossystonebrick,97,3 +silverfishmossstonebrick,97,3 +silverfishmstonebrick,97,3 +silverfishmsbrick,97,3 +sfishmossystonebrick,97,3 +sfishmossstonebrick,97,3 +sfishmstonebrick,97,3 +sfishmsbrick,97,3 +fishmossystonebrick,97,3 +fishmossstonebrick,97,3 +fishmstonebrick,97,3 +fishmsbrick,97,3 +sfmossystonebrick,97,3 +sfmossstonebrick,97,3 +sfmstonebrick,97,3 +sfmsbrick,97,3 +trapmossystonebrick,97,3 +trapmossstonebrick,97,3 +trapmstonebrick,97,3 +trapmsbrick,97,3 +monstereggmossystonebrick,97,3 +monstereggmossstonebrick,97,3 +monstereggmstonebrick,97,3 +monstereggmsbrick,97,3 +meggmossystonebrick,97,3 +meggmossstonebrick,97,3 +meggmstonebrick,97,3 +meggmsbrick,97,3 +memossystonebrick,97,3 +memossstonebrick,97,3 +memstonebrick,97,3 +memsbrick,97,3 +silverfishcrackedstonebrick,97,4 +silverfishcrackstonebrick,97,4 +silverfishcrstonebrick,97,4 +silverfishcrsbrick,97,4 +sfishcrackedstonebrick,97,4 +sfishcrackstonebrick,97,4 +sfishcrstonebrick,97,4 +sfishcrsbrick,97,4 +fishcrackedstonebrick,97,4 +fishcrackstonebrick,97,4 +fishcrstonebrick,97,4 +fishcrsbrick,97,4 +sfcrackedstonebrick,97,4 +sfcrackstonebrick,97,4 +sfcrstonebrick,97,4 +sfcrsbrick,97,4 +trapcrackedstonebrick,97,4 +trapcrackstonebrick,97,4 +trapcrstonebrick,97,4 +trapcrsbrick,97,4 +monstereggcrackedstonebrick,97,4 +monstereggcrackstonebrick,97,4 +monstereggcrstonebrick,97,4 +monstereggcrsbrick,97,4 +meggcrackedstonebrick,97,4 +meggcrackstonebrick,97,4 +meggcrstonebrick,97,4 +meggcrsbrick,97,4 +mecrackedstonebrick,97,4 +mecrackstonebrick,97,4 +mecrstonebrick,97,4 +mecrsbrick,97,4 +silverfishcirclestonebrick,97,5 +silverfishcistonebrick,97,5 +silverfishcisbrick,97,5 +sfishcirclestonebrick,97,5 +sfishcistonebrick,97,5 +sfishcisbrick,97,5 +fishcirclestonebrick,97,5 +fishcistonebrick,97,5 +fishcisbrick,97,5 +sfcirclestonebrick,97,5 +sfcistonebrick,97,5 +sfcisbrick,97,5 +trapcirclestonebrick,97,5 +trapcistonebrick,97,5 +trapcisbrick,97,5 +monstereggcirclestonebrick,97,5 +monstereggcistonebrick,97,5 +monstereggcisbrick,97,5 +meggcirclestonebrick,97,5 +meggcistonebrick,97,5 +meggcisbrick,97,5 +mecirclestonebrick,97,5 +mecistonebrick,97,5 +mecisbrick,97,5 +stonebrick,98,0 +stonebricks,98,0 +stonebrickblock,98,0 +stonebb,98,0 +sbrick,98,0 +mossystonebrick,98,1 +mossystonebricks,98,1 +mossystonebrickblock,98,1 +mossystonebb,98,1 +mossstonebrick,98,1 +mossstonebricks,98,1 +mossstonebrickblock,98,1 +mossstonebb,98,1 +mstonebrick,98,1 +mstonebricks,98,1 +mstonebrickblock,98,1 +mstonebb,98,1 +mosssbrick,98,1 +mosssbricks,98,1 +mosssbrickblock,98,1 +mosssbb,98,1 +msbrick,98,1 +msbricks,98,1 +msbrickblock,98,1 +csbrick,98,2 +crackedstone,98,2 +crackedstonebrick,98,2 +crackedstonebricks,98,2 +crackedstonebrickblock,98,2 +crackedstonebb,98,2 +crackstonebrick,98,2 +crackstonebricks,98,2 +crackstonebrickblock,98,2 +crackstonebb,98,2 +crstonebrick,98,2 +crstonebricks,98,2 +crstonebrickblock,98,2 +crstonebb,98,2 +cracksbrick,98,2 +cracksbricks,98,2 +cracksbrickblock,98,2 +cracksbb,98,2 +crsbrick,98,2 +crsbricks,98,2 +crsbrickblock,98,2 +crstone,98,3 +circlestone,98,3 +circlestonebrick,98,3 +circlestonebricks,98,3 +circlestonebrickblock,98,3 +circlestonebb,98,3 +cistonebrick,98,3 +cistonebricks,98,3 +cistonebrickblock,98,3 +cistonebb,98,3 +circlesbrick,98,3 +circlesbricks,98,3 +circlesbrickblock,98,3 +circlesbb,98,3 +cisbrick,98,3 +cisbricks,98,3 +cisbrickblock,98,3 +giantbrownmushroom,99,0 +hugebrownmushroom,99,0 +bigbrownmushroom,99,0 +gbrownmushroom,99,0 +hbrownmushroom,99,0 +bbrownmushroom,99,0 +giantbmushroom,99,0 +hugebmushroom,99,0 +bigbmushroom,99,0 +gbmushroom,99,0 +hbmushroom,99,0 +bbmushroom,99,0 +giantbrownmush,99,0 +hugebrownmush,99,0 +bigbrownmush,99,0 +gbrownmush,99,0 +hbrownmush,99,0 +bbrownmush,99,0 +giantbmush,99,0 +hugebmush,99,0 +bigbmush,99,0 +gbmush,99,0 +hbmush,99,0 +bbmush,99,0 +giantredmushroom,100,0 +hugeredmushroom,100,0 +bigredmushroom,100,0 +gredmushroom,100,0 +hredmushroom,100,0 +bredmushroom,100,0 +giantrmushroom,100,0 +hugermushroom,100,0 +bigrmushroom,100,0 +grmushroom,100,0 +hrmushroom,100,0 +brmushroom,100,0 +giantredmush,100,0 +hugeredmush,100,0 +bigredmush,100,0 +gredmush,100,0 +hredmush,100,0 +bredmush,100,0 +giantrmush,100,0 +hugermush,100,0 +bigrmush,100,0 +grmush,100,0 +hrmush,100,0 +brmush,100,0 +ironbars,101,0 +ironbarsb,101,0 +ironbarsblock,101,0 +ironfence,101,0 +metalbars,101,0 +metalbarsb,101,0 +metalbarsblock,101,0 +metalfence,101,0 +jailbars,101,0 +jailbarsb,101,0 +jailbarsblock,101,0 +jailfence,101,0 +mbars,101,0 +mbarsb,101,0 +mbarsblock,101,0 +mfence,101,0 +jbars,101,0 +jbarsb,101,0 +jbarsblock,101,0 +jfence,101,0 +ibars,101,0 +ibarsb,101,0 +ibarsblock,101,0 +ifence,101,0 +glasspane,102,0 +glassp,102,0 +paneglass,102,0 +pglass,102,0 +flatglass,102,0 +fglass,102,0 +skinnyglass,102,0 +glassflat,102,0 +glassf,102,0 +glassskinny,102,0 +glasss,102,0 +melon,103,0 +watermelon,103,0 +greenmelon,103,0 +melongreen,103,0 +melonblock,103,0 +watermelonblock,103,0 +greenmelonblock,103,0 +vines,106,0 +vine,106,0 +greenvines,106,0 +greenvine,106,0 +gardenvines,106,0 +gardenvine,106,0 +vinesgreen,106,0 +vinegreen,106,0 +vinesgarden,106,0 +vinegarden,106,0 +vinesg,106,0 +vineg,106,0 +gvines,106,0 +gvine,106,0 +woodgate,107,0 +woodenfencegate,107,0 +wfencegate,107,0 +woodfencegate,107,0 +woodengate,107,0 +wgate,107,0 +gate,107,0 +gardengate,107,0 +ggate,107,0 +fencegate,107,0 +fgate,107,0 +brickstairs,108,0 +redbrickstairs,108,0 +redbstairs,108,0 +rbrickstairs,108,0 +bstairs,108,0 +redstairs,108,0 +brickstair,108,0 +redbrickstair,108,0 +redbstair,108,0 +rbrickstair,108,0 +bstair,108,0 +redstair,108,0 +sbstair,109,0 +stonebrickstairs,109,0 +stonebstairs,109,0 +sbstairs,109,0 +cementbrickstairs,109,0 +cementstairs,109,0 +cementbstairs,109,0 +cbstairs,109,0 +greybrickstairs,109,0 +greybstairs,109,0 +greystairs,109,0 +mycelium,110,0 +purplegrass,110,0 +pinkgrass,110,0 +mycel,110,0 +swampgrass,110,0 +sgrass,110,0 +mushroomgrass,110,0 +mushgrass,110,0 +lilypad,111,0 +waterlily,111,0 +lily,111,0 +swamppad,111,0 +lpad,111,0 +wlily,111,0 +netherbrickblock,112,0 +hellbrickblock,112,0 +deathbrickblock,112,0 +nbrickblock,112,0 +hbrickblock,112,0 +dbrickblock,112,0 +netherbblock,112,0 +hellbblock,112,0 +deathbblock,112,0 +nbblock,112,0 +hbblock,112,0 +dbblock,112,0 +netherbrickfence,113,0 +hellbrickfence,113,0 +nbrickfence,113,0 +hbrickfence,113,0 +netherbfence,113,0 +hellbfence,113,0 +netherfence,113,0 +hellfence,113,0 +nbfence,113,0 +hbfence,113,0 +nfence,113,0 +hfence,113,0 +netherbrickstairs,114,0 +hellbrickstairs,114,0 +nbrickstairs,114,0 +hbrickstairs,114,0 +netherbstairs,114,0 +hellbstairs,114,0 +netherstairs,114,0 +hellstairs,114,0 +nbstairs,114,0 +hbstairs,114,0 +nstairs,114,0 +hstairs,114,0 +netherbrickstair,114,0 +hellbrickstair,114,0 +nbrickstair,114,0 +hbrickstair,114,0 +netherbstair,114,0 +hellbstair,114,0 +netherstair,114,0 +hellstair,114,0 +nbstair,114,0 +hbstair,114,0 +nstair,114,0 +hstair,114,0 +enchantmenttable,116,0 +enchantingtable,116,0 +enchanttable,116,0 +etable,116,0 +magicaltable,116,0 +magictable,116,0 +mtable,116,0 +enchantmentdesk,116,0 +enchantingdesk,116,0 +enchantdesk,116,0 +edesk,116,0 +magicaldesk,116,0 +magicdesk,116,0 +mdesk,116,0 +booktable,116,0 +bookdesk,116,0 +btable,116,0 +bdesk,116,0 +enderportal,119,0 +endergoo,119,0 +endgoo,119,0 +endportal,119,0 +egoo,119,0 +eportal,119,0 +enderportalframe,120,0 +endportalframe,120,0 +endgooframe,120,0 +endergooframe,120,0 +egooframe,120,0 +eportalframe,120,0 +enderframe,120,0 +endframe,120,0 +enderstone,121,0 +endstone,121,0 +endrock,121,0 +enderrock,121,0 +erock,121,0 +estone,121,0 +enderdragonegg,122,0 +endegg,122,0 +dragonegg,122,0 +degg,122,0 +bossegg,122,0 +begg,122,0 +redstonelamp,123,0 +redlamp,123,0 +rslamp,123,0 +woodendoublestep,125,0 +woodendstep,125,0 +wooddoublestep,125,0 +wooddstep,125,0 +wdoublestep,125,0 +wdstep,125,0 +doublewoodenstep,125,0 +dwoodenstep,125,0 +doublewoodstep,125,0 +dwoodstep,125,0 +doublewstep,125,0 +dwstep,125,0 +woodendoubleslab,125,0 +woodendslab,125,0 +wooddoubleslab,125,0 +wooddslab,125,0 +wdoubleslab,125,0 +wdslab,125,0 +doublewoodenslab,125,0 +dwoodenslab,125,0 +doublewoodslab,125,0 +dwoodslab,125,0 +doublewslab,125,0 +dwslab,125,0 +woodendoublehalfblock,125,0 +woodendhalfblock,125,0 +wooddoublehalfblock,125,0 +wooddhalfblock,125,0 +wdoublehalfblock,125,0 +wdhalfblock,125,0 +doublewoodenhalfblock,125,0 +dwoodenhalfblock,125,0 +doublewoodhalfblock,125,0 +dwoodhalfblock,125,0 +doublewhalfblock,125,0 +dwhalfblock,125,0 +oakwoodendoublehalfblock,125,0 +oakwoodendhalfblock,125,0 +oakwooddoublehalfblock,125,0 +oakwooddhalfblock,125,0 +oakwdoublehalfblock,125,0 +oakwdhalfblock,125,0 +oakdoublewoodenhalfblock,125,0 +oakdwoodenhalfblock,125,0 +oakdoublewoodhalfblock,125,0 +oakdwoodhalfblock,125,0 +oakdoublewhalfblock,125,0 +oakdwhalfblock,125,0 +oakdoublehalfblock,125,0 +oakdhalfblock,125,0 +odhalfblock,125,0 +oakwoodendoublestep,125,0 +oakwoodendstep,125,0 +oakwooddoublestep,125,0 +oakwooddstep,125,0 +oakwdoublestep,125,0 +oakwdstep,125,0 +oakdoublewoodenstep,125,0 +oakdwoodenstep,125,0 +oakdoublewoodstep,125,0 +oakdwoodstep,125,0 +oakdoublewstep,125,0 +oakdwstep,125,0 +oakdoublestep,125,0 +oakdstep,125,0 +odstep,125,0 +oakwoodendoubleslab,125,0 +oakwoodendslab,125,0 +oakwooddoubleslab,125,0 +oakwooddslab,125,0 +oakwdoubleslab,125,0 +oakwdslab,125,0 +oakdoublewoodenslab,125,0 +oakdwoodenslab,125,0 +oakdoublewoodslab,125,0 +oakdwoodslab,125,0 +oakdoublewslab,125,0 +oakdwslab,125,0 +oakdoubleslab,125,0 +oakdslab,125,0 +odslab,125,0 +sprucewoodendoublestep,125,1 +sprucewoodendstep,125,1 +sprucewooddoublestep,125,1 +sprucewooddstep,125,1 +sprucewdoublestep,125,1 +sprucewdstep,125,1 +sprucedoublewoodenstep,125,1 +sprucedwoodenstep,125,1 +sprucedoublewoodstep,125,1 +sprucedwoodstep,125,1 +sprucedoublewstep,125,1 +sprucedwstep,125,1 +sprucedoublestep,125,1 +sprucedstep,125,1 +sprucewoodendoubleslab,125,1 +sprucewoodendslab,125,1 +sprucewooddoubleslab,125,1 +sprucewooddslab,125,1 +sprucewdoubleslab,125,1 +sprucewdslab,125,1 +sprucedoublewoodenslab,125,1 +sprucedwoodenslab,125,1 +sprucedoublewoodslab,125,1 +sprucedwoodslab,125,1 +sprucedoublewslab,125,1 +sprucedwslab,125,1 +sprucedoubleslab,125,1 +sprucedslab,125,1 +sprucewoodendoublehalfblock,125,1 +sprucewoodendhalfblock,125,1 +sprucewooddoublehalfblock,125,1 +sprucewooddhalfblock,125,1 +sprucewdoublehalfblock,125,1 +sprucewdhalfblock,125,1 +sprucedoublewoodenhalfblock,125,1 +sprucedwoodenhalfblock,125,1 +sprucedoublewoodhalfblock,125,1 +sprucedwoodhalfblock,125,1 +sprucedoublewhalfblock,125,1 +sprucedwhalfblock,125,1 +sprucedoublehalfblock,125,1 +sprucedhalfblock,125,1 +darkwoodendoublestep,125,1 +darkwoodendstep,125,1 +darkwooddoublestep,125,1 +darkwooddstep,125,1 +darkwdoublestep,125,1 +darkwdstep,125,1 +darkdoublewoodenstep,125,1 +darkdwoodenstep,125,1 +darkdoublewoodstep,125,1 +darkdwoodstep,125,1 +darkdoublewstep,125,1 +darkdwstep,125,1 +darkdoublestep,125,1 +darkdstep,125,1 +ddstep,125,1 +darkwoodendoubleslab,125,1 +darkwoodendslab,125,1 +darkwooddoubleslab,125,1 +darkwooddslab,125,1 +darkwdoubleslab,125,1 +darkwdslab,125,1 +darkdoublewoodenslab,125,1 +darkdwoodenslab,125,1 +darkdoublewoodslab,125,1 +darkdwoodslab,125,1 +darkdoublewslab,125,1 +darkdwslab,125,1 +darkdoubleslab,125,1 +darkdslab,125,1 +ddslab,125,1 +darkwoodendoublehalfblock,125,1 +darkwoodendhalfblock,125,1 +darkwooddoublehalfblock,125,1 +darkwooddhalfblock,125,1 +darkwdoublehalfblock,125,1 +darkwdhalfblock,125,1 +darkdoublewoodenhalfblock,125,1 +darkdwoodenhalfblock,125,1 +darkdoublewoodhalfblock,125,1 +darkdwoodhalfblock,125,1 +darkdoublewhalfblock,125,1 +darkdwhalfblock,125,1 +darkdoublehalfblock,125,1 +darkdhalfblock,125,1 +ddhalfblock,125,1 +birchwoodendoublestep,125,2 +birchwoodendstep,125,2 +birchwooddoublestep,125,2 +birchwooddstep,125,2 +birchwdoublestep,125,2 +birchwdstep,125,2 +birchdoublewoodenstep,125,2 +birchdwoodenstep,125,2 +birchdoublewoodstep,125,2 +birchdwoodstep,125,2 +birchdoublewstep,125,2 +birchdwstep,125,2 +birchdoublestep,125,2 +birchdstep,125,2 +birchwoodendoubleslab,125,2 +birchwoodendslab,125,2 +birchwooddoubleslab,125,2 +birchwooddslab,125,2 +birchwdoubleslab,125,2 +birchwdslab,125,2 +birchdoublewoodenslab,125,2 +birchdwoodenslab,125,2 +birchdoublewoodslab,125,2 +birchdwoodslab,125,2 +birchdoublewslab,125,2 +birchdwslab,125,2 +birchdoubleslab,125,2 +birchdslab,125,2 +birchwoodendoublehalfblock,125,2 +birchwoodendhalfblock,125,2 +birchwooddoublehalfblock,125,2 +birchwooddhalfblock,125,2 +birchwdoublehalfblock,125,2 +birchwdhalfblock,125,2 +birchdoublewoodenhalfblock,125,2 +birchdwoodenhalfblock,125,2 +birchdoublewoodhalfblock,125,2 +birchdwoodhalfblock,125,2 +birchdoublewhalfblock,125,2 +birchdwhalfblock,125,2 +birchdoublehalfblock,125,2 +birchdhalfblock,125,2 +lightwoodendoublehalfblock,125,2 +lightwoodendhalfblock,125,2 +lightwooddoublehalfblock,125,2 +lightwooddhalfblock,125,2 +lightwdoublehalfblock,125,2 +lightwdhalfblock,125,2 +lightdoublewoodenhalfblock,125,2 +lightdwoodenhalfblock,125,2 +lightdoublewoodhalfblock,125,2 +lightdwoodhalfblock,125,2 +lightdoublewhalfblock,125,2 +lightdwhalfblock,125,2 +lightdoublehalfblock,125,2 +lightdhalfblock,125,2 +ldhalfblock,125,2 +lightwoodendoublestep,125,2 +lightwoodendstep,125,2 +lightwooddoublestep,125,2 +lightwooddstep,125,2 +lightwdoublestep,125,2 +lightwdstep,125,2 +lightdoublewoodenstep,125,2 +lightdwoodenstep,125,2 +lightdoublewoodstep,125,2 +lightdwoodstep,125,2 +lightdoublewstep,125,2 +lightdwstep,125,2 +lightdoublestep,125,2 +lightdstep,125,2 +ldstep,125,2 +lightwoodendoubleslab,125,2 +lightwoodendslab,125,2 +lightwooddoubleslab,125,2 +lightwooddslab,125,2 +lightwdoubleslab,125,2 +lightwdslab,125,2 +lightdoublewoodenslab,125,2 +lightdwoodenslab,125,2 +lightdoublewoodslab,125,2 +lightdwoodslab,125,2 +lightdoublewslab,125,2 +lightdwslab,125,2 +lightdoubleslab,125,2 +lightdslab,125,2 +ldslab,125,2 +junglewoodendoublestep,125,3 +junglewoodendstep,125,3 +junglewooddoublestep,125,3 +junglewooddstep,125,3 +junglewdoublestep,125,3 +junglewdstep,125,3 +jungledoublewoodenstep,125,3 +jungledwoodenstep,125,3 +jungledoublewoodstep,125,3 +jungledwoodstep,125,3 +jungledoublewstep,125,3 +jungledwstep,125,3 +jungledoublestep,125,3 +jungledstep,125,3 +jdstep,125,3 +junglewoodendoubleslab,125,3 +junglewoodendslab,125,3 +junglewooddoubleslab,125,3 +junglewooddslab,125,3 +junglewdoubleslab,125,3 +junglewdslab,125,3 +jungledoublewoodenslab,125,3 +jungledwoodenslab,125,3 +jungledoublewoodslab,125,3 +jungledwoodslab,125,3 +jungledoublewslab,125,3 +jungledwslab,125,3 +jungledoubleslab,125,3 +jungledslab,125,3 +jdslab,125,3 +junglewoodendoublehalfblock,125,3 +junglewoodendhalfblock,125,3 +junglewooddoublehalfblock,125,3 +junglewooddhalfblock,125,3 +junglewdoublehalfblock,125,3 +junglewdhalfblock,125,3 +jungledoublewoodenhalfblock,125,3 +jungledwoodenhalfblock,125,3 +jungledoublewoodhalfblock,125,3 +jungledwoodhalfblock,125,3 +jungledoublewhalfblock,125,3 +jungledwhalfblock,125,3 +jungledoublehalfblock,125,3 +jungledhalfblock,125,3 +jdhalfblock,125,3 +forestwoodendoublehalfblock,125,3 +forestwoodendhalfblock,125,3 +forestwooddoublehalfblock,125,3 +forestwooddhalfblock,125,3 +forestwdoublehalfblock,125,3 +forestwdhalfblock,125,3 +forestdoublewoodenhalfblock,125,3 +forestdwoodenhalfblock,125,3 +forestdoublewoodhalfblock,125,3 +forestdwoodhalfblock,125,3 +forestdoublewhalfblock,125,3 +forestdwhalfblock,125,3 +forestdoublehalfblock,125,3 +forestdhalfblock,125,3 +fdhalfblock,125,3 +forestwoodendoublestep,125,3 +forestwoodendstep,125,3 +forestwooddoublestep,125,3 +forestwooddstep,125,3 +forestwdoublestep,125,3 +forestwdstep,125,3 +forestdoublewoodenstep,125,3 +forestdwoodenstep,125,3 +forestdoublewoodstep,125,3 +forestdwoodstep,125,3 +forestdoublewstep,125,3 +forestdwstep,125,3 +forestdoublestep,125,3 +forestdstep,125,3 +fdstep,125,3 +forestwoodendoubleslab,125,3 +forestwoodendslab,125,3 +forestwooddoubleslab,125,3 +forestwooddslab,125,3 +forestwdoubleslab,125,3 +forestwdslab,125,3 +forestdoublewoodenslab,125,3 +forestdwoodenslab,125,3 +forestdoublewoodslab,125,3 +forestdwoodslab,125,3 +forestdoublewslab,125,3 +forestdwslab,125,3 +forestdoubleslab,125,3 +forestdslab,125,3 +fdslab,125,3 +acaciawoodendoublestep,125,4 +acaciawoodendstep,125,4 +acaciawooddoublestep,125,4 +acaciawooddstep,125,4 +acaciawdoublestep,125,4 +acaciawdstep,125,4 +acaciadoublewoodenstep,125,4 +acaciadwoodenstep,125,4 +acaciadoublewoodstep,125,4 +acaciadwoodstep,125,4 +acaciadoublewstep,125,4 +acaciadwstep,125,4 +acaciadoublestep,125,4 +acaciadstep,125,4 +adstep,125,4 +acaciawoodendoubleslab,125,4 +acaciawoodendslab,125,4 +acaciawooddoubleslab,125,4 +acaciawooddslab,125,4 +acaciawdoubleslab,125,4 +acaciawdslab,125,4 +acaciadoublewoodenslab,125,4 +acaciadwoodenslab,125,4 +acaciadoublewoodslab,125,4 +acaciadwoodslab,125,4 +acaciadoublewslab,125,4 +acaciadwslab,125,4 +acaciadoubleslab,125,4 +acaciadslab,125,4 +adslab,125,4 +acaciawoodendoublehalfblock,125,4 +acaciawoodendhalfblock,125,4 +acaciawooddoublehalfblock,125,4 +acaciawooddhalfblock,125,4 +acaciawdoublehalfblock,125,4 +acaciawdhalfblock,125,4 +acaciadoublewoodenhalfblock,125,4 +acaciadwoodenhalfblock,125,4 +acaciadoublewoodhalfblock,125,4 +acaciadwoodhalfblock,125,4 +acaciadoublewhalfblock,125,4 +acaciadwhalfblock,125,4 +acaciadoublehalfblock,125,4 +acaciadhalfblock,125,4 +adhalfblock,125,4 +darkoakwoodendoublehalfblock,125,5 +darkoakwoodendhalfblock,125,5 +darkoakwooddoublehalfblock,125,5 +darkoakwooddhalfblock,125,5 +darkoakwdoublehalfblock,125,5 +darkoakwdhalfblock,125,5 +darkoakdoublewoodenhalfblock,125,5 +darkoakdwoodenhalfblock,125,5 +darkoakdoublewoodhalfblock,125,5 +darkoakdwoodhalfblock,125,5 +darkoakdoublewhalfblock,125,5 +darkoakdwhalfblock,125,5 +darkoakdoublehalfblock,125,5 +darkoakdhalfblock,125,5 +dodhalfblock,125,5 +darkoakwoodendoublestep,125,5 +darkoakwoodendstep,125,5 +darkoakwooddoublestep,125,5 +darkoakwooddstep,125,5 +darkoakwdoublestep,125,5 +darkoakwdstep,125,5 +darkoakdoublewoodenstep,125,5 +darkoakdwoodenstep,125,5 +darkoakdoublewoodstep,125,5 +darkoakdwoodstep,125,5 +darkoakdoublewstep,125,5 +darkoakdwstep,125,5 +darkoakdoublestep,125,5 +darkoakdstep,125,5 +dodstep,125,5 +darkoakwoodendoubleslab,125,5 +darkoakwoodendslab,125,5 +darkoakwooddoubleslab,125,5 +darkoakwooddslab,125,5 +darkoakwdoubleslab,125,5 +darkoakwdslab,125,5 +darkoakdoublewoodenslab,125,5 +darkoakdwoodenslab,125,5 +darkoakdoublewoodslab,125,5 +darkoakdwoodslab,125,5 +darkoakdoublewslab,125,5 +darkoakdwslab,125,5 +darkoakdoubleslab,125,5 +darkoakdslab,125,5 +dodslab,125,5 +woodenstep,126,0 +woodstep,126,0 +wstep,126,0 +woodenslab,126,0 +woodslab,126,0 +wslab,126,0 +woodenhalfblock,126,0 +woodhalfblock,126,0 +whalfblock,126,0 +oakwoodenstep,126,0 +oakwoodstep,126,0 +oakwstep,126,0 +oakstep,126,0 +ostep,126,0 +oakwoodenslab,126,0 +oakwoodslab,126,0 +oakwslab,126,0 +oakslab,126,0 +oslab,126,0 +oakwoodenhalfblock,126,0 +oakwoodhalfblock,126,0 +oakwhalfblock,126,0 +oakhalfblock,126,0 +ohalfblock,126,0 +spslab,126,1 +spstep,126,1 +sprucewoodenstep,126,1 +sprucewoodstep,126,1 +sprucewstep,126,1 +sprucestep,126,1 +sprucewoodenslab,126,1 +sprucewoodslab,126,1 +sprucewslab,126,1 +spruceslab,126,1 +sprucewoodenhalfblock,126,1 +sprucewoodhalfblock,126,1 +sprucewhalfblock,126,1 +sprucehalfblock,126,1 +darkwoodenstep,126,1 +darkwoodstep,126,1 +darkwstep,126,1 +darkstep,126,1 +darkwoodenslab,126,1 +darkwoodslab,126,1 +darkwslab,126,1 +darkslab,126,1 +darkwoodenhalfblock,126,1 +darkwoodhalfblock,126,1 +darkwhalfblock,126,1 +darkhalfblock,126,1 +birchwoodenstep,126,2 +birchwoodstep,126,2 +birchwstep,126,2 +birchstep,126,2 +birchwoodenslab,126,2 +birchwoodslab,126,2 +birchwslab,126,2 +birchslab,126,2 +birchwoodenhalfblock,126,2 +birchwoodhalfblock,126,2 +birchwhalfblock,126,2 +birchhalfblock,126,2 +lightwoodenstep,126,2 +lightwoodstep,126,2 +lightwstep,126,2 +lightstep,126,2 +lstep,126,2 +lightwoodenslab,126,2 +lightwoodslab,126,2 +lightwslab,126,2 +lightslab,126,2 +lslab,126,2 +lightwoodenhalfblock,126,2 +lightwoodhalfblock,126,2 +lightwhalfblock,126,2 +lighthalfblock,126,2 +lhalfblock,126,2 +junglewoodenstep,126,3 +junglewoodstep,126,3 +junglewstep,126,3 +junglestep,126,3 +jstep,126,3 +junglewoodenslab,126,3 +junglewoodslab,126,3 +junglewslab,126,3 +jungleslab,126,3 +jslab,126,3 +junglewoodenhalfblock,126,3 +junglewoodhalfblock,126,3 +junglewhalfblock,126,3 +junglehalfblock,126,3 +jhalfblock,126,3 +forestwoodenstep,126,3 +forestwoodstep,126,3 +forestwstep,126,3 +foreststep,126,3 +fstep,126,3 +forestwoodenslab,126,3 +forestwoodslab,126,3 +forestwslab,126,3 +forestslab,126,3 +fslab,126,3 +forestwoodenhalfblock,126,3 +forestwoodhalfblock,126,3 +forestwhalfblock,126,3 +foresthalfblock,126,3 +fhalfblock,126,3 +acaciawoodenstep,126,4 +acaciawoodstep,126,4 +acaciawstep,126,4 +acaciastep,126,4 +astep,126,4 +acaciawoodenslab,126,4 +acaciawoodslab,126,4 +acaciawslab,126,4 +acaciaslab,126,4 +aslab,126,4 +acaciawoodenhalfblock,126,4 +acaciawoodhalfblock,126,4 +acaciawhalfblock,126,4 +acaciahalfblock,126,4 +ahalfblock,126,4 +darkoakwoodenstep,126,5 +darkoakwoodstep,126,5 +darkoakwstep,126,5 +darkoakstep,126,5 +dostep,126,5 +darkoakwoodenslab,126,5 +darkoakwoodslab,126,5 +darkoakwslab,126,5 +darkoakslab,126,5 +doslab,126,5 +darkoakwoodenhalfblock,126,5 +darkoakwoodhalfblock,126,5 +darkoakwhalfblock,126,5 +darkoakhalfblock,126,5 +dohalfblock,126,5 +cocoaplant,127,0 +cocoplant,127,0 +cplant,127,0 +cocoafruit,127,0 +cocofruit,127,0 +cfruit,127,0 +cocoapod,127,0 +cocopod,127,0 +cpod,127,0 +sandstonestairs,128,0 +sandstairs,128,0 +sandsstairs,128,0 +sstonestairs,128,0 +ssstairs,128,0 +sandstair,128,0 +sandstonestair,128,0 +sandsstair,128,0 +sstonestair,128,0 +ssstair,128,0 +emeraldore,129,0 +eore,129,0 +oreemerald,129,0 +oree,129,0 +enderchest,130,0 +endchest,130,0 +echest,130,0 +chestender,130,0 +chestend,130,0 +cheste,130,0 +endercontainer,130,0 +endcontainer,130,0 +econtainer,130,0 +tripwirehook,131,0 +tripwire,131,0 +trip,131,0 +tripwirelever,131,0 +triphook,131,0 +emeraldblock,133,0 +blockemerald,133,0 +eblock,133,0 +blocke,133,0 +sprucewoodenstairs,134,0 +sprucewoodstairs,134,0 +sprucewstairs,134,0 +sprucestairs,134,0 +darkwoodenstairs,134,0 +darkwoodstairs,134,0 +darkwstairs,134,0 +darkstairs,134,0 +dstairs,134,0 +sprucewoodenstair,134,0 +sprucewoodstair,134,0 +sprucewstair,134,0 +sprucestair,134,0 +darkwoodenstair,134,0 +darkwoodstair,134,0 +darkwstair,134,0 +darkstair,134,0 +dstair,134,0 +birchwoodenstairs,135,0 +birchwoodstairs,135,0 +birchwstairs,135,0 +birchstairs,135,0 +lightwoodenstairs,135,0 +lightwoodstairs,135,0 +lightwstairs,135,0 +lightstairs,135,0 +lstairs,135,0 +birchwoodenstair,135,0 +birchwoodstair,135,0 +birchwstair,135,0 +birchstair,135,0 +lightwoodenstair,135,0 +lightwoodstair,135,0 +lightwstair,135,0 +lightstair,135,0 +lstair,135,0 +junglewoodenstairs,136,0 +junglewoodstairs,136,0 +junglewstairs,136,0 +junglestairs,136,0 +jstairs,136,0 +forestwoodenstairs,136,0 +forestwoodstairs,136,0 +forestwstairs,136,0 +foreststairs,136,0 +fstairs,136,0 +junglewoodenstair,136,0 +junglewoodstair,136,0 +junglewstair,136,0 +junglestair,136,0 +jstair,136,0 +forestwoodenstair,136,0 +forestwoodstair,136,0 +forestwstair,136,0 +foreststair,136,0 +fstair,136,0 +commandblock,137,0 +blockcommand,137,0 +cmdblock,137,0 +blockcmd,137,0 +macroblock,137,0 +blockmacro,137,0 +beacon,138,0 +beaconblock,138,0 +cobblestonewall,139,0 +cstonewall,139,0 +cobblewall,139,0 +cobblestonefence,139,0 +cstonefence,139,0 +cobblefence,139,0 +cswall,139,0 +csfence,139,0 +cwall,139,0 +cfence,139,0 +mcswall,139,0 +mcsfence,139,0 +mcfence,139,0 +mcwall,139,1 +mosscobblestonewall,139,1 +mosscstonewall,139,1 +mosscobblewall,139,1 +mcobblestonewall,139,1 +mcstonewall,139,1 +mcobblewall,139,1 +mosscobblestonefence,139,1 +mosscstonefence,139,1 +mosscobblefence,139,1 +mcobblestonefence,139,1 +mcstonefence,139,1 +mcobblefence,139,1 +plantedcarrot,141,0 +plantcarrot,141,0 +carrots,141,0 +growingcarrot,141,0 +potatoplant,142,0 +potatoes,142,0 +plantedpotato,142,0 +plantpotato,142,0 +growingpotato,142,0 +woodenbutton,143,0 +woodenplankbutton,143,0 +woodplankbutton,143,0 +wplankbutton,143,0 +plankbutton,143,0 +woodbutton,143,0 +wbutton,143,0 +anvil,145,0 +slightlydamagedanvil,145,1 +slightdamageanvil,145,1 +damagedanvil,145,1 +verydamagedanvil,145,2 +trapchest,146,0 +trappedchest,146,0 +chesttrapped,146,0 +chesttrap,146,0 +goldpressureplate,147,0 +weightedgoldpressureplate,147,0 +weightgoldpressureplate,147,0 +wgoldpressureplate,147,0 +weightedgoldpressplate,147,0 +weightgoldpressplate,147,0 +wgoldpressplate,147,0 +goldpressplate,147,0 +weightedgoldpplate,147,0 +weightgoldpplate,147,0 +wgoldpplate,147,0 +goldpplate,147,0 +weightedgoldplate,147,0 +weightgoldplate,147,0 +wgoldplate,147,0 +goldplate,147,0 +weightedgpressureplate,147,0 +weightgpressureplate,147,0 +wgpressureplate,147,0 +gpressureplate,147,0 +weightedgpressplate,147,0 +weightgpressplate,147,0 +wgpressplate,147,0 +gpressplate,147,0 +weightedgpplate,147,0 +weightgpplate,147,0 +wgpplate,147,0 +gpplate,147,0 +weightedgplate,147,0 +weightgplate,147,0 +wgplate,147,0 +gplate,147,0 +ironpressureplate,148,0 +weightedironpressureplate,148,0 +weightironpressureplate,148,0 +wironpressureplate,148,0 +weightedironpressplate,148,0 +weightironpressplate,148,0 +wironpressplate,148,0 +ironpressplate,148,0 +weightedironpplate,148,0 +weightironpplate,148,0 +wironpplate,148,0 +ironpplate,148,0 +weightedironplate,148,0 +weightironplate,148,0 +wironplate,148,0 +ironplate,148,0 +weightedipressureplate,148,0 +weightipressureplate,148,0 +wipressureplate,148,0 +ipressureplate,148,0 +weightedipressplate,148,0 +weightipressplate,148,0 +wipressplate,148,0 +ipressplate,148,0 +weightedipplate,148,0 +weightipplate,148,0 +wipplate,148,0 +ipplate,148,0 +weightediplate,148,0 +weightiplate,148,0 +wiplate,148,0 +iplate,148,0 +daylightsensor,151,0 +daylightsense,151,0 +lightsensor,151,0 +lightsense,151,0 +daysensor,151,0 +daysense,151,0 +timesensor,151,0 +timesense,151,0 +redstoneblock,152,0 +rstoneblock,152,0 +redsblock,152,0 +rsblock,152,0 +blockredstone,152,0 +blockrstone,152,0 +blockreds,152,0 +blockrs,152,0 +netherquartzore,153,0 +hellquartzore,153,0 +deathquartzore,153,0 +nquartzore,153,0 +hquartzore,153,0 +dquartzore,153,0 +quartzore,153,0 +netherqore,153,0 +hellqore,153,0 +deathqore,153,0 +nqore,153,0 +hqore,153,0 +dqore,153,0 +qore,153,0 +hopper,154,0 +chestpuller,154,0 +chestpull,154,0 +cheststorer,154,0 +cheststore,154,0 +itempuller,154,0 +itempull,154,0 +itemstorer,154,0 +itemstore,154,0 +quartzblock,155,0 +netherquartzblock,155,0 +nqblock,155,0 +qblock,155,0 +chiseledquartzblock,155,1 +chiselquartzblock,155,1 +cquartzblock,155,1 +cqblock,155,1 +pillarquartzblock,155,2 +pquartzblock,155,2 +pqblock,155,2 +quartzstairs,156,0 +qstairs,156,0 +quartzstair,156,0 +qstair,156,0 +activatorrails,157,0 +activaterails,157,0 +triggerrails,157,0 +arails,157,0 +trails,157,0 +activatorrail,157,0 +activaterail,157,0 +triggerrail,157,0 +arail,157,0 +trail,157,0 +activatortrack,157,0 +activatetrack,157,0 +triggertrack,157,0 +atrack,157,0 +ttrack,157,0 +dropper,158,0 +drop,158,0 +chestdispenser,158,0 +chestdispense,158,0 +chestdropper,158,0 +chestdrop,158,0 +whiteclay,159,0 +whitesclay,159,0 +whitestainedclay,159,0 +wclay,159,0 +wsclay,159,0 +wstainedclay,159,0 +sclay,159,0 +stainedclay,159,0 +whiteterracota,159,0 +whiteterra,159,0 +whitetcota,159,0 +wterracota,159,0 +wterra,159,0 +wtcota,159,0 +orangeclay,159,1 +orangesclay,159,1 +orangestainedclay,159,1 +oclay,159,1 +osclay,159,1 +ostainedclay,159,1 +orangeterracota,159,1 +orangeterra,159,1 +orangetcota,159,1 +oterracota,159,1 +oterra,159,1 +otcota,159,1 +magentaclay,159,2 +magentasclay,159,2 +magentastainedclay,159,2 +mclay,159,2 +msclay,159,2 +mstainedclay,159,2 +magentaterracota,159,2 +magentaterra,159,2 +magentatcota,159,2 +mterracota,159,2 +mterra,159,2 +mtcota,159,2 +lightblueclay,159,3 +lightbluesclay,159,3 +lightbluestainedclay,159,3 +lblueclay,159,3 +lbluesclay,159,3 +lbluestainedclay,159,3 +lightbluclay,159,3 +lightblusclay,159,3 +lightblustainedclay,159,3 +lbluclay,159,3 +lblusclay,159,3 +lblustainedclay,159,3 +lbclay,159,3 +lbsclay,159,3 +lbstainedclay,159,3 +lightblueterracota,159,3 +lightblueterra,159,3 +lightbluetcota,159,3 +lightbluterracota,159,3 +lightbluterra,159,3 +lightblutcota,159,3 +lblueterracota,159,3 +lblueterra,159,3 +lbluetcota,159,3 +lbluterracota,159,3 +lbluterra,159,3 +lblutcota,159,3 +lbterracota,159,3 +lbterra,159,3 +lbtcota,159,3 +yellowclay,159,4 +yellowsclay,159,4 +yellowstainedclay,159,4 +yclay,159,4 +ysclay,159,4 +ystainedclay,159,4 +yellowterracota,159,4 +yellowterra,159,4 +yellowtcota,159,4 +yterracota,159,4 +yterra,159,4 +ytcota,159,4 +lightgreenclay,159,5 +lightgreensclay,159,5 +lightgreenstainedclay,159,5 +lgreenclay,159,5 +lgreensclay,159,5 +lgreenstainedclay,159,5 +lightgreclay,159,5 +lightgresclay,159,5 +lightgrestainedclay,159,5 +lgreclay,159,5 +lgresclay,159,5 +lgrestainedclay,159,5 +limeclay,159,5 +limesclay,159,5 +limestainedclay,159,5 +lclay,159,5 +lsclay,159,5 +lstainedclay,159,5 +lightgreenterracota,159,5 +lightgreenterra,159,5 +lightgreentcota,159,5 +lgreenterracota,159,5 +lgreenterra,159,5 +lgreentcota,159,5 +lightgreterracota,159,5 +lightgreterra,159,5 +lightgretcota,159,5 +lgreterracota,159,5 +lgreterra,159,5 +lgretcota,159,5 +limeterracota,159,5 +limeterra,159,5 +limetcota,159,5 +lterracota,159,5 +lterra,159,5 +ltcota,159,5 +pinkclay,159,6 +pinksclay,159,6 +pinkstainedclay,159,6 +piclay,159,6 +pisclay,159,6 +pistainedclay,159,6 +pinkterracota,159,6 +pinkterra,159,6 +pinktcota,159,6 +piterracota,159,6 +piterra,159,6 +pitcota,159,6 +darkgrayclay,159,7 +darkgraysclay,159,7 +darkgraystainedclay,159,7 +dgrayclay,159,7 +dgraysclay,159,7 +dgraystainedclay,159,7 +darkgreyclay,159,7 +darkgreysclay,159,7 +darkgreystainedclay,159,7 +dgreyclay,159,7 +dgreysclay,159,7 +dgreystainedclay,159,7 +darkgraclay,159,7 +darkgrasclay,159,7 +darkgrastainedclay,159,7 +dgraclay,159,7 +dgrasclay,159,7 +dgrastainedclay,159,7 +grayclay,159,7 +graysclay,159,7 +graystainedclay,159,7 +greyclay,159,7 +greysclay,159,7 +greystainedclay,159,7 +graclay,159,7 +grasclay,159,7 +grastainedclay,159,7 +darkgrayterracota,159,7 +darkgrayterra,159,7 +darkgraytcota,159,7 +dgrayterracota,159,7 +dgrayterra,159,7 +dgraytcota,159,7 +darkgreyterracota,159,7 +darkgreyterra,159,7 +darkgreytcota,159,7 +dgreyterracota,159,7 +dgreyterra,159,7 +dgreytcota,159,7 +darkgraterracota,159,7 +darkgraterra,159,7 +darkgratcota,159,7 +dgraterracota,159,7 +dgraterra,159,7 +dgratcota,159,7 +grayterracota,159,7 +grayterra,159,7 +graytcota,159,7 +greyterracota,159,7 +greyterra,159,7 +greytcota,159,7 +graterracota,159,7 +graterra,159,7 +gratcota,159,7 +lgclay,159,8 +lightgrayclay,159,8 +lightgraysclay,159,8 +lightgraystainedclay,159,8 +lgrayclay,159,8 +lgraysclay,159,8 +lgraystainedclay,159,8 +lightgreyclay,159,8 +lightgreysclay,159,8 +lightgreystainedclay,159,8 +lgreyclay,159,8 +lgreysclay,159,8 +lgreystainedclay,159,8 +lightgraclay,159,8 +lightgrasclay,159,8 +lightgrastainedclay,159,8 +lgraclay,159,8 +lgrasclay,159,8 +lgrastainedclay,159,8 +silverclay,159,8 +silversclay,159,8 +silverstainedclay,159,8 +siclay,159,8 +siasclay,159,8 +siastainedclay,159,8 +lgterracota,159,8 +lgterra,159,8 +lgtcota,159,8 +lightgrayterracota,159,8 +lightgrayterra,159,8 +lightgraytcota,159,8 +lgrayterracota,159,8 +lgrayterra,159,8 +lgraytcota,159,8 +lightgreyterracota,159,8 +lightgreyterra,159,8 +lightgreytcota,159,8 +lgreyterracota,159,8 +lgreyterra,159,8 +lgreytcota,159,8 +lightgraterracota,159,8 +lightgraterra,159,8 +lightgratcota,159,8 +lgraterracota,159,8 +lgraterra,159,8 +lgratcota,159,8 +silverterracota,159,8 +silverterra,159,8 +silvertcota,159,8 +siterracota,159,8 +siterra,159,8 +sitcota,159,8 +cyanclay,159,9 +cyansclay,159,9 +cyanstainedclay,159,9 +cclay,159,9 +csclay,159,9 +cstainedclay,159,9 +cyanterracota,159,9 +cyanterra,159,9 +cyantcota,159,9 +cterracota,159,9 +cterra,159,9 +ctcota,159,9 +purpleclay,159,10 +purplesclay,159,10 +purplestainedclay,159,10 +puclay,159,10 +pusclay,159,10 +pustainedclay,159,10 +purpleterracota,159,10 +purpleterra,159,10 +purpletcota,159,10 +puterracota,159,10 +puterra,159,10 +putcota,159,10 +blueclay,159,11 +bluesclay,159,11 +bluestainedclay,159,11 +bluclay,159,11 +blusclay,159,11 +blustainedclay,159,11 +blueterracota,159,11 +blueterra,159,11 +bluetcota,159,11 +bluterracota,159,11 +bluterra,159,11 +blutcota,159,11 +brownclay,159,12 +brownsclay,159,12 +brownstainedclay,159,12 +broclay,159,12 +brosclay,159,12 +brostainedclay,159,12 +brownterracota,159,12 +brownterra,159,12 +browntcota,159,12 +broterracota,159,12 +broterra,159,12 +brotcota,159,12 +darkgreenclay,159,13 +darkgreensclay,159,13 +darkgreenstainedclay,159,13 +dgreenclay,159,13 +dgreensclay,159,13 +dgreenstainedclay,159,13 +greenclay,159,13 +greensclay,159,13 +greenstainedclay,159,13 +darkgreclay,159,13 +darkgresclay,159,13 +darkgrestainedclay,159,13 +dgreclay,159,13 +dgresclay,159,13 +dgrestainedclay,159,13 +greclay,159,13 +gresclay,159,13 +grestainedclay,159,13 +darkgreenterracota,159,13 +darkgreenterra,159,13 +darkgreentcota,159,13 +dgreenterracota,159,13 +dgreenterra,159,13 +dgreentcota,159,13 +greenterracota,159,13 +greenterra,159,13 +greentcota,159,13 +darkgreterracota,159,13 +darkgreterra,159,13 +darkgretcota,159,13 +dgreterracota,159,13 +dgreterra,159,13 +dgretcota,159,13 +greterracota,159,13 +greterra,159,13 +gretcota,159,13 +redclay,159,14 +redsclay,159,14 +redstainedclay,159,14 +rclay,159,14 +rsclay,159,14 +rstainedclay,159,14 +redterracota,159,14 +redterra,159,14 +redtcota,159,14 +rterracota,159,14 +rterra,159,14 +rtcota,159,14 +blackclay,159,15 +blacksclay,159,15 +blackstainedclay,159,15 +blaclay,159,15 +blasclay,159,15 +blastainedclay,159,15 +blackterracota,159,15 +blackterra,159,15 +blacktcota,159,15 +blaterracota,159,15 +blaterra,159,15 +blatcota,159,15 +wgpane,160,0 +whiteglasspane,160,0 +whitesglasspane,160,0 +whitestainedglasspane,160,0 +wglasspane,160,0 +wsglasspane,160,0 +wstainedglasspane,160,0 +sglasspane,160,0 +stainedglasspane,160,0 +ogpane,160,1 +orangeglasspane,160,1 +orangesglasspane,160,1 +orangestainedglasspane,160,1 +oglasspane,160,1 +osglasspane,160,1 +ostainedglasspane,160,1 +mgpane,160,2 +magentaglasspane,160,2 +magentasglasspane,160,2 +magentastainedglasspane,160,2 +mglasspane,160,2 +msglasspane,160,2 +mstainedglasspane,160,2 +lbpane,160,3 +lightblueglasspane,160,3 +lightbluesglasspane,160,3 +lightbluestainedglasspane,160,3 +lblueglasspane,160,3 +lbluesglasspane,160,3 +lbluestainedglasspane,160,3 +lightbluglasspane,160,3 +lightblusglasspane,160,3 +lightblustainedglasspane,160,3 +lbluglasspane,160,3 +lblusglasspane,160,3 +lblustainedglasspane,160,3 +lbglasspane,160,3 +lbsglasspane,160,3 +lbstainedglasspane,160,3 +ygpane,160,4 +yellowglasspane,160,4 +yellowsglasspane,160,4 +yellowstainedglasspane,160,4 +yglasspane,160,4 +ysglasspane,160,4 +ystainedglasspane,160,4 +lgrpane,160,5 +lightgreenglasspane,160,5 +lightgreensglasspane,160,5 +lightgreenstainedglasspane,160,5 +lgreenglasspane,160,5 +lgreensglasspane,160,5 +lgreenstainedglasspane,160,5 +lightgreglasspane,160,5 +lightgresglasspane,160,5 +lightgrestainedglasspane,160,5 +lgreglasspane,160,5 +lgresglasspane,160,5 +lgrestainedglasspane,160,5 +limeglasspane,160,5 +limesglasspane,160,5 +limestainedglasspane,160,5 +lglasspane,160,5 +lsglasspane,160,5 +lstainedglasspane,160,5 +pgpane,160,6 +pinkglasspane,160,6 +pinksglasspane,160,6 +pinkstainedglasspane,160,6 +piglasspane,160,6 +pisglasspane,160,6 +pistainedglasspane,160,6 +dgpane,160,7 +darkgrayglasspane,160,7 +darkgraysglasspane,160,7 +darkgraystainedglasspane,160,7 +dgrayglasspane,160,7 +dgraysglasspane,160,7 +dgraystainedglasspane,160,7 +darkgreyglasspane,160,7 +darkgreysglasspane,160,7 +darkgreystainedglasspane,160,7 +dgreyglasspane,160,7 +dgreysglasspane,160,7 +dgreystainedglasspane,160,7 +darkgraglasspane,160,7 +darkgrasglasspane,160,7 +darkgrastainedglasspane,160,7 +dgraglasspane,160,7 +dgrasglasspane,160,7 +dgrastainedglasspane,160,7 +grayglasspane,160,7 +graysglasspane,160,7 +graystainedglasspane,160,7 +greyglasspane,160,7 +greysglasspane,160,7 +greystainedglasspane,160,7 +graglasspane,160,7 +grasglasspane,160,7 +grastainedglasspane,160,7 +lgypane,160,8 +lightgrayglasspane,160,8 +lightgraysglasspane,160,8 +lightgraystainedglasspane,160,8 +lgrayglasspane,160,8 +lgraysglasspane,160,8 +lgraystainedglasspane,160,8 +lightgreyglasspane,160,8 +lightgreysglasspane,160,8 +lightgreystainedglasspane,160,8 +lgreyglasspane,160,8 +lgreysglasspane,160,8 +lgreystainedglasspane,160,8 +lightgraglasspane,160,8 +lightgrasglasspane,160,8 +lightgrastainedglasspane,160,8 +lgraglasspane,160,8 +lgrasglasspane,160,8 +lgrastainedglasspane,160,8 +silverglasspane,160,8 +silversglasspane,160,8 +silverstainedglasspane,160,8 +siglasspane,160,8 +siasglasspane,160,8 +siastainedglasspane,160,8 +cgpane,160,9 +cyanglasspane,160,9 +cyansglasspane,160,9 +cyanstainedglasspane,160,9 +cglasspane,160,9 +csglasspane,160,9 +cstainedglasspane,160,9 +prpane,160,10 +purpleglasspane,160,10 +purplesglasspane,160,10 +purplestainedglasspane,160,10 +puglasspane,160,10 +pusglasspane,160,10 +pustainedglasspane,160,10 +bgpane,160,11 +blueglasspane,160,11 +bluesglasspane,160,11 +bluestainedglasspane,160,11 +bluglasspane,160,11 +blusglasspane,160,11 +blustainedglasspane,160,11 +brgpane,160,12 +brownglasspane,160,12 +brownsglasspane,160,12 +brownstainedglasspane,160,12 +broglasspane,160,12 +brosglasspane,160,12 +brostainedglasspane,160,12 +dgrpane,160,13 +darkgreenglasspane,160,13 +darkgreensglasspane,160,13 +darkgreenstainedglasspane,160,13 +dgreenglasspane,160,13 +dgreensglasspane,160,13 +dgreenstainedglasspane,160,13 +greenglasspane,160,13 +greensglasspane,160,13 +greenstainedglasspane,160,13 +darkgreglasspane,160,13 +darkgresglasspane,160,13 +darkgrestainedglasspane,160,13 +dgreglasspane,160,13 +dgresglasspane,160,13 +dgrestainedglasspane,160,13 +greglasspane,160,13 +gresglasspane,160,13 +grestainedglasspane,160,13 +rgpane,160,14 +redglasspane,160,14 +redsglasspane,160,14 +redstainedglasspane,160,14 +rglasspane,160,14 +rsglasspane,160,14 +rstainedglasspane,160,14 +blgpane,160,15 +blackglasspane,160,15 +blacksglasspane,160,15 +blackstainedglasspane,160,15 +blaglasspane,160,15 +blasglasspane,160,15 +blastainedglasspane,160,15 +acacialeaves,161,0 +acaciatreeleaves,161,0 +acacialogleaves,161,0 +acaciatrunkleaves,161,0 +acaciawoodleaves,161,0 +aleaves,161,0 +atreeleaves,161,0 +alogleaves,161,0 +atrunkleaves,161,0 +awoodleaves,161,0 +acacialeave,161,0 +acaciatreeleave,161,0 +acacialogleave,161,0 +acaciatrunkleave,161,0 +acaciawoodleave,161,0 +aleave,161,0 +atreeleave,161,0 +alogleave,161,0 +atrunkleave,161,0 +awoodleave,161,0 +acaciatreeleaf,161,0 +acacialogleaf,161,0 +acaciatrunkleaf,161,0 +acaciawoodleaf,161,0 +aleaf,161,0 +atreeleaf,161,0 +alogleaf,161,0 +atrunkleaf,161,0 +awoodleaf,161,0 +darkoakleaves,161,1 +darkoaktreeleaves,161,1 +darkoaklogleaves,161,1 +darkoaktrunkleaves,161,1 +darkoakwoodleaves,161,1 +doakleaves,161,1 +doaktreeleaves,161,1 +doaklogleaves,161,1 +doaktrunkleaves,161,1 +doakwoodleaves,161,1 +doleaves,161,1 +dotreeleaves,161,1 +dologleaves,161,1 +dotrunkleaves,161,1 +dowoodleaves,161,1 +darkoakleave,161,1 +darkoaktreeleave,161,1 +darkoaklogleave,161,1 +darkoaktrunkleave,161,1 +darkoakwoodleave,161,1 +doakleave,161,1 +doaktreeleave,161,1 +doaklogleave,161,1 +doaktrunkleave,161,1 +doakwoodleave,161,1 +doleave,161,1 +dotreeleave,161,1 +dologleave,161,1 +dotrunkleave,161,1 +dowoodleave,161,1 +darkoaktreeleaf,161,1 +darkoaklogleaf,161,1 +darkoaktrunkleaf,161,1 +darkoakwoodleaf,161,1 +doakleaf,161,1 +doaktreeleaf,161,1 +doaklogleaf,161,1 +doaktrunkleaf,161,1 +doakwoodleaf,161,1 +doleaf,161,1 +dotreeleaf,161,1 +dologleaf,161,1 +dotrunkleaf,161,1 +dowoodleaf,161,1 +acacia,162,0 +acaciatree,162,0 +acacialog,162,0 +acaciatrunk,162,0 +acaciawood,162,0 +atree,162,0 +alog,162,0 +atrunk,162,0 +awood,162,0 +darkoak,162,1 +darkoaktree,162,1 +darkoaklog,162,1 +darkoaktrunk,162,1 +darkoakwood,162,1 +doak,162,1 +doaktree,162,1 +doaklog,162,1 +doaktrunk,162,1 +doakwood,162,1 +dotree,162,1 +dolog,162,1 +dotrunk,162,1 +dowood,162,1 +acaciawoodenstairs,163,0 +acaciawoodstairs,163,0 +acaciawstairs,163,0 +acaciastairs,163,0 +awoodenstairs,163,0 +awoodstairs,163,0 +awstairs,163,0 +astairs,163,0 +acaciawoodenstair,163,0 +acaciawoodstair,163,0 +acaciawstair,163,0 +acaciastair,163,0 +awoodenstair,163,0 +awoodstair,163,0 +awstair,163,0 +astair,163,0 +darkoakwoodenstairs,164,0 +darkoakwoodstairs,164,0 +darkoakwstairs,164,0 +darkoakstairs,164,0 +doakwoodenstairs,164,0 +doakwoodstairs,164,0 +doakwstairs,164,0 +doakstairs,164,0 +dowoodenstairs,164,0 +dowoodstairs,164,0 +dowstairs,164,0 +dostairs,164,0 +darkoakwoodenstair,164,0 +darkoakwoodstair,164,0 +darkoakwstair,164,0 +darkoakstair,164,0 +doakwoodenstair,164,0 +doakwoodstair,164,0 +doakwstair,164,0 +doakstair,164,0 +dowoodenstair,164,0 +dowoodstair,164,0 +dowstair,164,0 +dostair,164,0 +slime,165,0 +slimeblock,165,0 +barrier,166,0 +barrierblock,166,0 +irontrapdoor,167,0 +itrapdoor,167,0 +irondoortrap,167,0 +idoortrap,167,0 +pris,168,0 +prismarine,168,0 +prismarineblock,168,0 +pbrick,168,1 +prismarinebrick,168,1 +dpris,168,2 +darkprismarine,168,2 +lantern,169,0 +sealantern,169,0 +sealanternblock,169,0 +hay,170,0 +hayblock,170,0 +haybale,170,0 +baleofhay,170,0 +hayofbale,170,0 +whitecarpet,171,0 +whitefloor,171,0 +wcarpet,171,0 +wfloor,171,0 +carpet,171,0 +floor,171,0 +orangecarpet,171,1 +orangefloor,171,1 +ocarpet,171,1 +ofloor,171,1 +magentacarpet,171,2 +magentafloor,171,2 +mcarpet,171,2 +mfloor,171,2 +lightbluecarpet,171,3 +lightbluefloor,171,3 +lbluecarpet,171,3 +lbluefloor,171,3 +lbcarpet,171,3 +lbfloor,171,3 +lightblucarpet,171,3 +lightblufloor,171,3 +lblucarpet,171,3 +lblufloor,171,3 +yellowcarpet,171,4 +yellowfloor,171,4 +ycarpet,171,4 +yfloor,171,4 +lightgreencarpet,171,5 +lightgreenfloor,171,5 +lgreencarpet,171,5 +lgreenfloor,171,5 +lightgrecarpet,171,5 +lightgrefloor,171,5 +lgrecarpet,171,5 +lgrefloor,171,5 +limecarpet,171,5 +limefloor,171,5 +lcarpet,171,5 +lfloor,171,5 +pinkcarpet,171,6 +pinkfloor,171,6 +picarpet,171,6 +pifloor,171,6 +grfloor,171,7 +darkgraycarpet,171,7 +darkgrayfloor,171,7 +dgraycarpet,171,7 +dgrayfloor,171,7 +darkgreycarpet,171,7 +darkgreyfloor,171,7 +dgreycarpet,171,7 +dgreyfloor,171,7 +darkgracarpet,171,7 +darkgrafloor,171,7 +dgracarpet,171,7 +dgrafloor,171,7 +graycarpet,171,7 +grayfloor,171,7 +greycarpet,171,7 +greyfloor,171,7 +gracarpet,171,7 +grafloor,171,7 +lgfloor,171,8 +lightgraycarpet,171,8 +lightgrayfloor,171,8 +lgraycarpet,171,8 +lgrayfloor,171,8 +lightgreycarpet,171,8 +lightgreyfloor,171,8 +lgreycarpet,171,8 +lgreyfloor,171,8 +lightgracarpet,171,8 +lightgrafloor,171,8 +lgracarpet,171,8 +lgrafloor,171,8 +silvercarpet,171,8 +silverfloor,171,8 +sicarpet,171,8 +siafloor,171,8 +cyancarpet,171,9 +cyanfloor,171,9 +ccarpet,171,9 +cfloor,171,9 +purplecarpet,171,10 +purplefloor,171,10 +pucarpet,171,10 +pufloor,171,10 +blfloor,171,11 +bluecarpet,171,11 +bluefloor,171,11 +blucarpet,171,11 +blufloor,171,11 +brfloor,171,12 +browncarpet,171,12 +brownfloor,171,12 +brocarpet,171,12 +brofloor,171,12 +dgfloor,171,13 +darkgreencarpet,171,13 +darkgreenfloor,171,13 +dgreencarpet,171,13 +dgreenfloor,171,13 +greencarpet,171,13 +greenfloor,171,13 +darkgrecarpet,171,13 +darkgrefloor,171,13 +dgrecarpet,171,13 +dgrefloor,171,13 +grecarpet,171,13 +grefloor,171,13 +redcarpet,171,14 +redfloor,171,14 +rcarpet,171,14 +rfloor,171,14 +bkfloor,171,15 +blackcarpet,171,15 +blackfloor,171,15 +blacarpet,171,15 +blafloor,171,15 +hardenedclay,172,0 +hardclay,172,0 +hclay,172,0 +terracota,172,0 +terra,172,0 +tcota,172,0 +coalblock,173,0 +blockcoal,173,0 +coblock,173,0 +blockco,173,0 +coalb,173,0 +bcoal,173,0 +packedice,174,0 +packice,174,0 +solidice,174,0 +sunflower,175,0 +yellowsunflower,175,0 +lilac,175,1 +magentalilac,175,1 +syringa,175,1 +longtallgrass,175,2 +extratallgrass,175,2 +doubletallgrass,175,2 +largetallgrass,175,2 +longtgrass,175,2 +extratgrass,175,2 +doubletgrass,175,2 +largetgrass,175,2 +ltgrass,175,2 +etgrass,175,2 +dtgrass,175,2 +bigfern,175,3 +largefern,175,3 +doublefern,175,3 +bfern,175,3 +lfern,175,3 +dfern,175,3 +rosebush,175,4 +redrosebush,175,4 +peony,175,5 +pinkpeony,175,5 +paeonia,175,5 +inverteddaylightsensor,178,0 +daylightsensorinverted,178,0 +daylightdetectorinverted,178,0 +inverteddaylightdetector,178,0 +rsstone,179,0 +redsandstone,179,0 +crstone,179,1 +redsandstonechiseled,179,1 +chiseledredsandstone,179,1 +srstone,179,2 +redsandstonesmooth,179,2 +smoothredsandstone,179,2 +redsandstonestair,180,0 +redsandstonestairs,180,0 +rsstair,180,0 +stairredsandstone,180,0 +doubleredsandstoneslab,181,0 +doubleredsandstoneslabfull,181,8 +fullredsandstoneslab,181,8 +rsslab,182,0 +redsandstoneslab,182,0 +sprucefencegate,183,0 +sfencegate,183,0 +sgate,183,0 +sprucegate,183,0 +birchfencegate,184,0 +bfencegate,184,0 +bgate,184,0 +birchgate,184,0 +junglefencegate,185,0 +jfencegate,185,0 +jgate,185,0 +junglegate,185,0 +darkoakfencegate,186,0 +doakfencegate,186,0 +darkoakgate,186,0 +doakgate,186,0 +dogate,186,0 +acaciafencegate,187,0 +afencegate,187,0 +acaciagate,187,0 +agate,187,0 +sprucefence,188,0 +sfence,188,0 +birchfence,189,0 +bfence,189,0 +junglefence,190,0 +jfence,190,0 +darkoakfence,191,0 +dofence,191,0 +doakfence,191,0 +acaciafence,192,0 +afence,192,0 +sprucedoor,193,0 +birchdoor,194,0 +jungledoor,195,0 +acaciadoor,196,0 +darkoakdoor,197,0 +endrod,198,0 +enderrod,198,0 +erod,198,0 +endlight,198,0 +elight,198,0 +endtorch,198,0 +etorch,198,0 +chorusplant,199,0 +corusplant,199,0 +chorusstem,199,0 +corusstem,199,0 +endplant,199,0 +enderplant,199,0 +chorusflower,200,0 +corusflower,200,0 +chorusblock,200,0 +endflower,200,0 +enderflower,200,0 +purpurblock,201,0 +purblock,201,0 +purpleblock,201,0 +purplestone,201,0 +purstone,201,0 +purpurpillar,202,0 +purpillar,202,0 +purpillarblock,202,0 +purpillarstone,202,0 +purpillar,202,0 +purplepillar,202,0 +purpurcollum,202,0 +purcollum,202,0 +purplecollum,202,0 +purpurstairs,203,0 +purpurstep,203,0 +purpursteps,203,0 +purplestairs,203,0 +purplesteps,203,0 +purplestep,203,0 +purstairs,203,0 +pursteps,203,0 +purstep,203,0 +purpurdoubleslab,205,0 +purpurslab,205,0 +purpurhalf,205,0 +purslab,205,0 +purpleslab,205,0 +purhalf,205,0 +purplehalf,205,0 +endstonebricks,206,0 +endbricks,206,0 +enderbricks,206,0 +ebricks,206,0 +ebrick,206,0 +beetrootblock,207,0 +grasspath,208,0 +gpath,208,0 +path,208,0 +pathblock,208,0 +dirtpath,208,0 +dpath,208,0 +worngrass,208,0 +grasswalkway,208,0 +dirtwalkway,208,0 +endgateway,209,0 +eislandportal,209,0 +endgate,209,0 +endergate,209,0 +repeatingcommandblock,210,0 +repeatcommandblock,210,0 +repeatingcmdblock,210,0 +repeatcmdblock,210,0 +chaincommandblock,211,0 +chaincmdblock,211,0 +frostedice,212,0 +frostediceblock,212,0 +frostice,212,0 +frosticeblock,212,0 +magmablock,213,0 +blockmagma,213,0 +netherwartblock,214,0 +blocknetherwart,214,0 +rednetherbrick,215,0 +rednetherbrickblock,215,0 +blockrednetherbrick,215,0 +rednbblock,215,0 +blockrednb,215,0 +boneblock,216,0 +skeletonboneblock,216,0 +skeletonblock,216,0 +structurevoid,217,0 +observer,218,0 +budblock,218,0 +bud,218,0 +shulkerbox,219,0 +whiteshulkerbox,219,0 +wshulkerbox,219,0 +whitechest,219,0 +wchest,219,0 +orangeshulkerbox,220,0 +oshulkerbox,220,0 +orangechest,220,0 +ochest,220,0 +magentashulkerbox,221,0 +magentachest,221,0 +mshulkerbox,221,0 +mchest,221,0 +mashulkerbox,221,0 +machest,221,0 +lightblueshulkerbox,222,0 +lightbluechest,222,0 +lblueshulkerbox,222,0 +lbluechest,222,0 +lbshulkerbox,222,0 +lbchest,222,0 +lblushulkerbox,222,0 +lightbluchest,222,0 +lbluchest,222,0 +yellowshulkerbox,223,0 +yshulkerbox,223,0 +yellowchest,223,0 +ychest,223,0 +limeshulkerbox,224,0 +lshulkerbox,224,0 +lgreenshulkerbox,224,0 +lgreshulkerbox,224,0 +limechest,224,0 +lgrechest,224,0 +lchest,224,0 +pinkshulkerbox,225,0 +pishulkerbox,225,0 +pinkchest,225,0 +pichest,225,0 +grayshulkerbox,226,0 +greyshulkerbox,226,0 +darkgrayshulkerbox,226,0 +darkgreyshulkerbox,226,0 +dgrayshulkerbox,226,0 +dgreyshulkerbox,226,0 +grashulkerbox,226,0 +greshulkerbox,226,0 +dgrashulkerbox,226,0 +dgreshulkerbox,226,0 +graychest,226,0 +greychest,226,0 +darkgraychest,226,0 +darkgreychest,226,0 +dgraychest,226,0 +dgreychest,226,0 +grachest,226,0 +darkgrachest,226,0 +dgrachest,226,0 +silvershulkerbox,227,0 +silverchest,227,0 +sishulkerbox,227,0 +sichest,227,0 +lgshulkerbox,227,0 +lgchest,227,0 +lightgrayshulkerbox,227,0 +lightgreyshulkerbox,227,0 +lightgraychest,227,0 +lightgreychest,227,0 +lightgrashulkerbox,227,0 +lightgreshulkerbox,227,0 +lightgrachest,227,0 +lightgrechest,227,0 +lgraychest,227,0 +lgreychest,227,0 +lgrachest,227,0 +lgrechest,227,0 +cyanshulkerbox,228,0 +cyanchest,228,0 +cshulkerbox,228,0 +cchest,228,0 +purpleshulkerbox,229,0 +purplechest,229,0 +pushulkerbox,229,0 +puchest,229,0 +blueshulkerbox,230,0 +bluechest,230,0 +blushulkerbox,230,0 +bluchest,230,0 +brownshulkerbox,231,0 +brownchest,231,0 +broshulkerbox,231,0 +brochest,231,0 +darkgreenshulkerbox,232,0 +darkgreenchest,232,0 +greenshulkerbox,232,0 +greenchest,232,0 +greenshulkerbox,232,0 +greenchest,232,0 +greshulkerbox,232,0 +grechest,232,0 +dgreshulkerbox,232,0 +dgrechest,232,0 +darkgreshulkerbox,232,0 +darkgrechest,232,0 +redshulkerbox,233,0 +rshulkerbox,233,0 +redchest,233,0 +rchest,233,0 +blackshulkerbox,234,0 +blashulkerbox,234,0 +blackchest,234,0 +blachest,234,0 +whiteglazedterracota,235,0 +whiteglazedterra,235,0 +whiteglazedtcota,235,0 +wglazedterracota,235,0 +wglazedterra,235,0 +wglazedtcota,235,0 +orangeglazedterracota,236,0 +orangeglazedterra,236,0 +orangeglazedtcota,236,0 +oglazedterracota,236,0 +oglazedterra,236,0 +oglazedtcota,236,0 +magentaglazedterracota,237,0 +magentaglazedterra,237,0 +magentaglazedtcota,237,0 +mglazedterracota,237,0 +mglazedterra,237,0 +mglazedtcota,237,0 +lightblueglazedterracota,238,0 +lightblueglazedterra,238,0 +lightblueglazedtcota,238,0 +lightbluglazedterracota,238,0 +lightbluglazedterra,238,0 +lightbluglazedtcota,238,0 +lblueglazedterracota,238,0 +lblueglazedterra,238,0 +lblueglazedtcota,238,0 +lbluglazedterracota,238,0 +lbluglazedterra,238,0 +lbluglazedtcota,238,0 +lbglazedterracota,238,0 +lbglazedterra,238,0 +lbglazedtcota,238,0 +yellowglazedterracota,239,0 +yellowglazedterra,239,0 +yellowglazedtcota,239,0 +yglazedterracota,239,0 +yglazedterra,239,0 +yglazedtcota,239,0 +lightgreenglazedterracota,240,0 +lightgreenglazedterra,240,0 +lightgreenglazedtcota,240,0 +lgreenglazedterracota,240,0 +lgreenglazedterra,240,0 +lgreenglazedtcota,240,0 +lightgreglazedterracota,240,0 +lightgreglazedterra,240,0 +lightgreglazedtcota,240,0 +lgreglazedterracota,240,0 +lgreglazedterra,240,0 +lgreglazedtcota,240,0 +limeglazedterracota,240,0 +limeglazedterra,240,0 +limeglazedtcota,240,0 +lglazedterracota,240,0 +lglazedterra,240,0 +lglazedtcota,240,0 +pinkglazedterracota,241,0 +pinkglazedterra,241,0 +pinkglazedtcota,241,0 +piglazedterracota,241,0 +piglazedterra,241,0 +piglazedtcota,241,0 +darkgrayglazedterracota,242,0 +darkgrayglazedterra,242,0 +darkgrayglazedtcota,242,0 +dgrayglazedterracota,242,0 +dgrayglazedterra,242,0 +dgrayglazedtcota,242,0 +darkgreyglazedterracota,242,0 +darkgreyglazedterra,242,0 +darkgreyglazedtcota,242,0 +dgreyglazedterracota,242,0 +dgreyglazedterra,242,0 +dgreyglazedtcota,242,0 +darkgraglazedterracota,242,0 +darkgraglazedterra,242,0 +darkgraglazedtcota,242,0 +dgraglazedterracota,242,0 +dgraglazedterra,242,0 +dgraglazedtcota,242,0 +grayglazedterracota,242,0 +grayglazedterra,242,0 +grayglazedtcota,242,0 +greyglazedterracota,242,0 +greyglazedterra,242,0 +greyglazedtcota,242,0 +graglazedterracota,242,0 +graglazedterra,242,0 +graglazedtcota,242,0 +lgglazedterracota,243,0 +lgglazedterra,243,0 +lgglazedtcota,243,0 +lightgrayglazedterracota,243,0 +lightgrayglazedterra,243,0 +lightgrayglazedtcota,243,0 +lgrayglazedterracota,243,0 +lgrayglazedterra,243,0 +lgrayglazedtcota,243,0 +lightgreyglazedterracota,243,0 +lightgreyglazedterra,243,0 +lightgreyglazedtcota,243,0 +lgreyglazedterracota,243,0 +lgreyglazedterra,243,0 +lgreyglazedtcota,243,0 +lightgraglazedterracota,243,0 +lightgraglazedterra,243,0 +lightgraglazedtcota,243,0 +lgraglazedterracota,243,0 +lgraglazedterra,243,0 +lgraglazedtcota,243,0 +silverglazedterracota,243,0 +silverglazedterra,243,0 +silverglazedtcota,243,0 +siglazedterracota,243,0 +siglazedterra,243,0 +siglazedtcota,243,0 +cyanglazedterracota,244,0 +cyanglazedterra,244,0 +cyanglazedtcota,244,0 +cglazedterracota,244,0 +cglazedterra,244,0 +cglazedtcota,244,0 +purpleglazedterracota,245,0 +purpleglazedterra,245,0 +purpleglazedtcota,245,0 +puglazedterracota,245,0 +puglazedterra,245,0 +puglazedtcota,245,0 +blueglazedterracota,246,0 +blueglazedterra,246,0 +blueglazedtcota,246,0 +bluglazedterracota,246,0 +bluglazedterra,246,0 +bluglazedtcota,246,0 +brownglazedterracota,247,0 +brownglazedterra,247,0 +brownglazedtcota,247,0 +broglazedterracota,247,0 +broglazedterra,247,0 +broglazedtcota,247,0 +darkgreenglazedterracota,248,0 +darkgreenglazedterra,248,0 +darkgreenglazedtcota,248,0 +dgreenglazedterracota,248,0 +dgreenglazedterra,248,0 +dgreenglazedtcota,248,0 +greenglazedterracota,248,0 +greenglazedterra,248,0 +greenglazedtcota,248,0 +darkgreglazedterracota,248,0 +darkgreglazedterra,248,0 +darkgreglazedtcota,248,0 +dgreglazedterracota,248,0 +dgreglazedterra,248,0 +dgreglazedtcota,248,0 +greglazedterracota,248,0 +greglazedterra,248,0 +greglazedtcota,248,0 +redglazedterracota,249,0 +redglazedterra,249,0 +redglazedtcota,249,0 +rglazedterracota,249,0 +rglazedterra,249,0 +rglazedtcota,249,0 +blackglazedterracota,250,0 +blackglazedterra,250,0 +blackglazedtcota,250,0 +blaglazedterracota,250,0 +blaglazedterra,250,0 +blaglazedtcota,250,0 +whiteconcrete,251,0 +wconcrete,251,0 +orangeconcrete,251,1 +oconcrete,251,1 +magentaconcrete,251,2 +mconcrete,251,2 +lightblueconcrete,251,3 +lightbluconcrete,251,3 +lblueconcrete,251,3 +lbluconcrete,251,3 +lbconcrete,251,3 +yellowconcrete,251,4 +yconcrete,251,4 +lightgreenconcrete,251,5 +lgreenconcrete,251,5 +lightgreconcrete,251,5 +lgreconcrete,251,5 +limeconcrete,251,5 +lconcrete,251,5 +pinkconcrete,251,6 +piconcrete,251,6 +darkgrayconcrete,251,7 +dgrayconcrete,251,7 +darkgreyconcrete,251,7 +dgreyconcrete,251,7 +darkgraconcrete,251,7 +dgraconcrete,251,7 +grayconcrete,251,7 +greyconcrete,251,7 +graconcrete,251,7 +lgconcrete,251,8 +lightgrayconcrete,251,8 +lgrayconcrete,251,8 +lightgreyconcrete,251,8 +lgreyconcrete,251,8 +lightgraconcrete,251,8 +lgraconcrete,251,8 +silverconcrete,251,8 +siconcrete,251,8 +cyanconcrete,251,9 +cconcrete,251,9 +purpleconcrete,251,10 +puconcrete,251,10 +blueconcrete,251,11 +bluconcrete,251,11 +brownconcrete,251,12 +broconcrete,251,12 +darkgreenconcrete,251,13 +dgreenconcrete,251,13 +greenconcrete,251,13 +darkgreconcrete,251,13 +dgreconcrete,251,13 +greconcrete,251,13 +redconcrete,251,14 +rconcrete,251,14 +blackconcrete,251,15 +blaconcrete,251,15 +whiteconcretepowder,252,0 +whiteconcretesand,252,0 +wconcretepowder,252,0 +wconcretesand,252,0 +orangeconcretepowder,252,1 +orangeconcretesand,252,1 +oconcretepowder,252,1 +oconcretesand,252,1 +magentaconcretepowder,252,2 +magentaconcretesand,252,2 +mconcretepowder,252,2 +mconcretesand,252,2 +lightblueconcretepowder,252,3 +lightblueconcretesand,252,3 +lightbluconcretepowder,252,3 +lightbluconcretesand,252,3 +lblueconcretepowder,252,3 +lblueconcretesand,252,3 +lbluconcretepowder,252,3 +lbluconcretesand,252,3 +lbconcretepowder,252,3 +lbconcretesand,252,3 +yellowconcretepowder,252,4 +yellowconcretesand,252,4 +yconcretepowder,252,4 +yconcretesand,252,4 +lightgreenconcretepowder,252,5 +lightgreenconcretesand,252,5 +lgreenconcretepowder,252,5 +lgreenconcretesand,252,5 +lightgreconcretepowder,252,5 +lightgreconcretesand,252,5 +lgreconcretepowder,252,5 +lgreconcretesand,252,5 +limeconcretepowder,252,5 +limeconcretesand,252,5 +lconcretepowder,252,5 +lconcretesand,252,5 +pinkconcretepowder,252,6 +pinkconcretesand,252,6 +piconcretepowder,252,6 +piconcretesand,252,6 +darkgrayconcretepowder,252,7 +darkgrayconcretesand,252,7 +dgrayconcretepowder,252,7 +dgrayconcretesand,252,7 +darkgreyconcretepowder,252,7 +darkgreyconcretesand,252,7 +dgreyconcretepowder,252,7 +dgreyconcretesand,252,7 +darkgraconcretepowder,252,7 +darkgraconcretesand,252,7 +dgraconcretepowder,252,7 +dgraconcretesand,252,7 +grayconcretepowder,252,7 +grayconcretesand,252,7 +greyconcretepowder,252,7 +greyconcretesand,252,7 +graconcretepowder,252,7 +graconcretesand,252,7 +lgconcretepowder,252,8 +lgconcretesand,252,8 +lightgrayconcretepowder,252,8 +lightgrayconcretesand,252,8 +lgrayconcretepowder,252,8 +lgrayconcretesand,252,8 +lightgreyconcretepowder,252,8 +lightgreyconcretesand,252,8 +lgreyconcretepowder,252,8 +lgreyconcretesand,252,8 +lightgraconcretepowder,252,8 +lightgraconcretesand,252,8 +lgraconcretepowder,252,8 +lgraconcretesand,252,8 +silverconcretepowder,252,8 +silverconcretesand,252,8 +siconcretepowder,252,8 +siconcretesand,252,8 +cyanconcretepowder,252,9 +cyanconcretesand,252,9 +cconcretepowder,252,9 +cconcretesand,252,9 +purpleconcretepowder,252,10 +purpleconcretesand,252,10 +puconcretepowder,252,10 +puconcretesand,252,10 +blueconcretepowder,252,11 +blueconcretesand,252,11 +bluconcretepowder,252,11 +bluconcretesand,252,11 +brownconcretepowder,252,12 +brownconcretesand,252,12 +broconcretepowder,252,12 +broconcretesand,252,12 +darkgreenconcretepowder,252,13 +darkgreenconcretesand,252,13 +dgreenconcretepowder,252,13 +dgreenconcretesand,252,13 +greenconcretepowder,252,13 +greenconcretesand,252,13 +darkgreconcretepowder,252,13 +darkgreconcretesand,252,13 +dgreconcretepowder,252,13 +dgreconcretesand,252,13 +greconcretepowder,252,13 +greconcretesand,252,13 +redconcretepowder,252,14 +redconcretesand,252,14 +rconcretepowder,252,14 +rconcretesand,252,14 +blackconcretepowder,252,15 +blackconcretesand,252,15 +blaconcretepowder,252,15 +blaconcretesand,252,15 +structureblock,255,0 +ironshovel,256,0 +ironspade,256,0 +ishovel,256,0 +ispade,256,0 +steelshovel,256,0 +steelspade,256,0 +ironpickaxe,257,0 +ironpick,257,0 +steelpickaxe,257,0 +steelpick,257,0 +ipickaxe,257,0 +ipick,257,0 +ironaxe,258,0 +iaxe,258,0 +steelaxe,258,0 +flintandsteel,259,0 +flintandiron,259,0 +flintandtinder,259,0 +flintnsteel,259,0 +flintniron,259,0 +flintntinder,259,0 +flintsteel,259,0 +flintiron,259,0 +flinttinder,259,0 +lighter,259,0 +apple,260,0 +normalapple,260,0 +redapple,260,0 +bow,261,0 +arrow,262,0 +coal,263,0 +charcoal,263,1 +ccoal,263,1 +diamond,264,0 +crystal,264,0 +ironingot,265,0 +ironbar,265,0 +ironi,265,0 +steelingot,265,0 +steelbar,265,0 +steeli,265,0 +iingot,265,0 +ibar,265,0 +ingotiron,265,0 +bariron,265,0 +iiron,265,0 +ingotsteel,265,0 +barsteel,265,0 +isteel,265,0 +ingoti,265,0 +bari,265,0 +ironnugget,452,0 +nuggeti,452,0 +inugget,452,0 +goldingot,266,0 +goldbar,266,0 +goldi,266,0 +gingot,266,0 +gbar,266,0 +ingotgold,266,0 +bargold,266,0 +igold,266,0 +ingotg,266,0 +barg,266,0 +ironsword,267,0 +steelsword,267,0 +isword,267,0 +woodensword,268,0 +woodsword,268,0 +wsword,268,0 +woodenshovel,269,0 +woodenspade,269,0 +woodshovel,269,0 +woodspade,269,0 +wshovel,269,0 +wspade,269,0 +woodenpickaxe,270,0 +woodenpick,270,0 +woodpickaxe,270,0 +woodpick,270,0 +wpickaxe,270,0 +wpick,270,0 +woodenaxe,271,0 +woodaxe,271,0 +waxe,271,0 +stonesword,272,0 +cobblestonesword,272,0 +cstonesword,272,0 +cssword,272,0 +ssword,272,0 +stoneshovel,273,0 +cobblestoneshovel,273,0 +cobblestonespade,273,0 +cstoneshovel,273,0 +cstonespade,273,0 +stonespade,273,0 +csshovel,273,0 +csspade,273,0 +sshovel,273,0 +sspade,273,0 +stonepickaxe,274,0 +cobblestonepickaxe,274,0 +cobblestonepick,274,0 +cstonepickaxe,274,0 +cstonepick,274,0 +stonepick,274,0 +cspickaxe,274,0 +cspick,274,0 +spickaxe,274,0 +spick,274,0 +stoneaxe,275,0 +cobblestoneaxe,275,0 +cstoneaxe,275,0 +csaxe,275,0 +saxe,275,0 +diamondsword,276,0 +crystalsword,276,0 +dsword,276,0 +diamondshovel,277,0 +diamondspade,277,0 +crystalshovel,277,0 +crystalspade,277,0 +dshovel,277,0 +dspade,277,0 +diamondpickaxe,278,0 +diamondpick,278,0 +crystalpickaxe,278,0 +crystalpick,278,0 +dpickaxe,278,0 +dpick,278,0 +diamondaxe,279,0 +crystalaxe,279,0 +daxe,279,0 +stick,280,0 +twig,280,0 +branch,280,0 +bowl,281,0 +woodenbowl,281,0 +woodbowl,281,0 +mushroomsoup,282,0 +mrsoup,282,0 +soup,282,0 +goldsword,283,0 +gsword,283,0 +goldshovel,284,0 +goldspade,284,0 +gshovel,284,0 +gspade,284,0 +goldpickaxe,285,0 +goldpick,285,0 +gpickaxe,285,0 +gpick,285,0 +goldaxe,286,0 +gaxe,286,0 +string,287,0 +thread,287,0 +feather,288,0 +gunpowder,289,0 +sulfur,289,0 +woodenhoe,290,0 +woodhoe,290,0 +whoe,290,0 +stonehoe,291,0 +cobblestonehoe,291,0 +cstonehoe,291,0 +cshoe,291,0 +shoe,291,0 +ironhoe,292,0 +steelhoe,292,0 +ihoe,292,0 +diamondhoe,293,0 +crystalhoe,293,0 +dhoe,293,0 +goldhoe,294,0 +ghoe,294,0 +seeds,295,0 +seed,295,0 +wheat,296,0 +crops,296,0 +crop,296,0 +bread,297,0 +leatherhelmet,298,0 +leatherhelm,298,0 +leatherhat,298,0 +leathercoif,298,0 +lhelmet,298,0 +lhelm,298,0 +lhat,298,0 +lcoif,298,0 +leatherchestplate,299,0 +leatherplatebody,299,0 +leatherplate,299,0 +leathershirt,299,0 +leathertunic,299,0 +lchestplate,299,0 +lplatebody,299,0 +lplate,299,0 +lshirt,299,0 +ltunic,299,0 +leatherleggings,300,0 +leatherlegs,300,0 +leatherpants,300,0 +lleggings,300,0 +llegs,300,0 +lpants,300,0 +leatherboots,301,0 +leathershoes,301,0 +lboots,301,0 +lshoes,301,0 +chainmailhelmet,302,0 +chainmailhelm,302,0 +chainmailhat,302,0 +chainmailcoif,302,0 +chainmhelmet,302,0 +chainmhelm,302,0 +chainmhat,302,0 +chainmcoif,302,0 +cmailhelmet,302,0 +cmailhelm,302,0 +cmailhat,302,0 +cmailcoif,302,0 +chainhelmet,302,0 +chainhelm,302,0 +chainhat,302,0 +chaincoif,302,0 +cmhelmet,302,0 +cmhelm,302,0 +cmhat,302,0 +cmcoif,302,0 +chainmailchestplate,303,0 +chainmailplatebody,303,0 +chainmailplate,303,0 +chainmailshirt,303,0 +chainmailtunic,303,0 +chainmchestplate,303,0 +chainmplatebody,303,0 +chainmplate,303,0 +chainmshirt,303,0 +chainmtunic,303,0 +cmailchestplate,303,0 +cmailplatebody,303,0 +cmailplate,303,0 +cmailshirt,303,0 +cmailtunic,303,0 +chainchestplate,303,0 +chainplatebody,303,0 +chainplate,303,0 +chainshirt,303,0 +chaintunic,303,0 +cmchestplate,303,0 +cmplatebody,303,0 +cmplate,303,0 +cmshirt,303,0 +cmtunic,303,0 +chainmailleggings,304,0 +chainmaillegs,304,0 +chainmailpants,304,0 +chainmleggings,304,0 +chainmlegs,304,0 +chainmpants,304,0 +cmailleggings,304,0 +cmaillegs,304,0 +cmailpants,304,0 +chainleggings,304,0 +chainlegs,304,0 +chainpants,304,0 +cmleggings,304,0 +cmlegs,304,0 +cmpants,304,0 +chainmailboots,305,0 +chainmailshoes,305,0 +chainmboots,305,0 +chainmshoes,305,0 +cmailboots,305,0 +cmailshoes,305,0 +chainboots,305,0 +chainshoes,305,0 +cmboots,305,0 +cmshoes,305,0 +ironhelmet,306,0 +ironhelm,306,0 +ironhat,306,0 +ironcoif,306,0 +ihelmet,306,0 +ihelm,306,0 +ihat,306,0 +icoif,306,0 +steelhelmet,306,0 +steelhelm,306,0 +steelhat,306,0 +steelcoif,306,0 +shelmet,306,0 +shelm,306,0 +shat,306,0 +scoif,306,0 +ironchestplate,307,0 +ironplatebody,307,0 +ironshirt,307,0 +irontunic,307,0 +ichestplate,307,0 +iplatebody,307,0 +ishirt,307,0 +itunic,307,0 +steelchestplate,307,0 +steelplatebody,307,0 +steelplate,307,0 +steelshirt,307,0 +steeltunic,307,0 +schestplate,307,0 +splatebody,307,0 +sshirt,307,0 +stunic,307,0 +ironleggings,308,0 +ironlegs,308,0 +ironpants,308,0 +ileggings,308,0 +ilegs,308,0 +ipants,308,0 +steelleggings,308,0 +steellegs,308,0 +steelpants,308,0 +sleggings,308,0 +slegs,308,0 +spants,308,0 +ironboots,309,0 +ironshoes,309,0 +iboots,309,0 +ishoes,309,0 +steelboots,309,0 +steelshoes,309,0 +sboots,309,0 +sshoes,309,0 +diamondhelmet,310,0 +diamondhelm,310,0 +diamondhat,310,0 +diamondcoif,310,0 +dhelmet,310,0 +dhelm,310,0 +dhat,310,0 +dcoif,310,0 +crystalhelmet,310,0 +crystalhelm,310,0 +crystalhat,310,0 +crystalcoif,310,0 +chelmet,310,0 +chelm,310,0 +chat,310,0 +ccoif,310,0 +diamondchestplate,311,0 +diamondplatebody,311,0 +diamondplate,311,0 +diamondshirt,311,0 +diamondtunic,311,0 +dchestplate,311,0 +dplatebody,311,0 +dplate,311,0 +dshirt,311,0 +dtunic,311,0 +crystalchestplate,311,0 +crystalplatebody,311,0 +crystalplate,311,0 +crystalshirt,311,0 +crystaltunic,311,0 +cchestplate,311,0 +cplatebody,311,0 +cplate,311,0 +cshirt,311,0 +ctunic,311,0 +diamondleggings,312,0 +diamondlegs,312,0 +diamondpants,312,0 +dleggings,312,0 +dlegs,312,0 +dpants,312,0 +crystalleggings,312,0 +crystallegs,312,0 +crystalpants,312,0 +cleggings,312,0 +clegs,312,0 +cpants,312,0 +diamondboots,313,0 +diamondshoes,313,0 +dboots,313,0 +dshoes,313,0 +crystalboots,313,0 +crystalshoes,313,0 +cboots,313,0 +cshoes,313,0 +goldhelmet,314,0 +goldhelm,314,0 +goldhat,314,0 +goldcoif,314,0 +ghelmet,314,0 +ghelm,314,0 +ghat,314,0 +gcoif,314,0 +goldchestplate,315,0 +goldplatebody,315,0 +goldshirt,315,0 +goldtunic,315,0 +gchestplate,315,0 +gplatebody,315,0 +gplateplate,315,0 +gshirt,315,0 +gtunic,315,0 +goldleggings,316,0 +goldlegs,316,0 +goldpants,316,0 +gleggings,316,0 +glegs,316,0 +gpants,316,0 +goldboots,317,0 +goldshoes,317,0 +gboots,317,0 +gshoes,317,0 +flint,318,0 +pork,319,0 +porkchop,319,0 +rawpork,319,0 +rpork,319,0 +rawporkchop,319,0 +rporkchop,319,0 +cookedpork,320,0 +grilledpork,320,0 +grillpork,320,0 +gpork,320,0 +cookpork,320,0 +cpork,320,0 +grilledporkchop,320,0 +grillporkchop,320,0 +gporkchop,320,0 +cookedporkchop,320,0 +cookporkchop,320,0 +cporkchop,320,0 +bacon,320,0 +painting,321,0 +picture,321,0 +goldenapple,322,0 +goldapple,322,0 +gapple,322,0 +enchantedgoldenapple,322,1 +enchantedgoldapple,322,1 +enchantedgapple,322,1 +supergoldenapple,322,1 +supergoldapple,322,1 +supergapple,322,1 +magicalgoldenapple,322,1 +magicalgoldapple,322,1 +magicalgapple,322,1 +magicgoldenapple,322,1 +magicgoldapple,322,1 +magicgapple,322,1 +egoldenapple,322,1 +egoldapple,322,1 +egapple,322,1 +sgoldenapple,322,1 +sgoldapple,322,1 +sgapple,322,1 +mgoldenapple,322,1 +mgoldapple,322,1 +mgapple,322,1 +sign,323,0 +woodendoor,324,0 +wooddoor,324,0 +wdoor,324,0 +door,324,0 +oakdoor,324,0 +odoor,324,0 +bucket,325,0 +bukkit,325,0 +waterbucket,326,0 +waterbukkit,326,0 +wbucket,326,0 +wbukkit,326,0 +magmabucket,327,0 +magmabukkit,327,0 +lavabucket,327,0 +lavabukkit,327,0 +lbucket,327,0 +lbukkit,327,0 +minecart,328,0 +mcart,328,0 +cart,328,0 +saddle,329,0 +irondoor,330,0 +idoor,330,0 +steeldoor,330,0 +sdoor,330,0 +dooriron,330,0 +doori,330,0 +doorsteel,330,0 +doors,330,0 +redstonedust,331,0 +redstone,331,0 +rstonedust,331,0 +rstone,331,0 +redsdust,331,0 +reddust,331,0 +rsdust,331,0 +rdust,331,0 +snow,332,0 +snowball,332,0 +snball,332,0 +sball,332,0 +boat,333,0 +leather,334,0 +cowhide,334,0 +hide,334,0 +milkbucket,335,0 +milkbukkit,335,0 +mbucket,335,0 +mbukkit,335,0 +claybrick,336,0 +brick,336,0 +redbrick,336,0 +rbrick,336,0 +clayball,337,0 +cball,337,0 +clay,337,0 +reeds,338,0 +reed,338,0 +sugarcane,338,0 +scane,338,0 +bamboo,338,0 +paper,339,0 +papyrus,339,0 +book,340,0 +slimeball,341,0 +slball,341,0 +chestminecart,342,0 +storageminecart,342,0 +storagemcart,342,0 +chestmcart,342,0 +storagecart,342,0 +chestcart,342,0 +sminecart,342,0 +cminecart,342,0 +smcart,342,0 +cmcart,342,0 +scart,342,0 +ccart,342,0 +furnaceminecart,343,0 +engineminecart,343,0 +poweredminecart,343,0 +powerminecart,343,0 +enginemcart,343,0 +poweredmcart,343,0 +powermcart,343,0 +furnacemcart,343,0 +enginecart,343,0 +poweredcart,343,0 +powercart,343,0 +furnacecart,343,0 +eminecart,343,0 +pminecart,343,0 +fminecart,343,0 +emcart,343,0 +pmcart,343,0 +fmcart,343,0 +ecart,343,0 +pcart,343,0 +fcart,343,0 +egg,344,0 +compass,345,0 +fishingrod,346,0 +fishrod,346,0 +frod,346,0 +rod,346,0 +watch,347,0 +goldwatch,347,0 +goldclock,347,0 +gwatch,347,0 +gclock,347,0 +clock,347,0 +glowstonedust,348,0 +glowingstonedust,348,0 +lightstonedust,348,0 +lbdust,348,0 +gbdust,348,0 +lsdust,348,0 +gsdust,348,0 +rawfish,349,0 +rafish,349,0 +fish,349,0 +rawsalmonfish,349,1 +rasalmonfish,349,1 +salmonfish,349,1 +rawsalmon,349,1 +rasalmon,349,1 +salmon,349,1 +sfish,349,1 +fishs,349,1 +rawclownfish,349,2 +raclownfish,349,2 +clownfish,349,2 +rawnemo,349,2 +ranemo,349,2 +nemo,349,2 +nemofish,349,2 +fishnemo,349,2 +clfish,349,2 +fishcl,349,2 +nfish,349,2 +fishn,349,2 +rawpufferfish,349,3 +rapufferfish,349,3 +pufferfish,349,3 +pufffish,349,3 +fishpuff,349,3 +pfish,349,3 +fishp,349,3 +cookedfish,350,0 +cookfish,350,0 +cfish,350,0 +grilledfish,350,0 +grillfish,350,0 +gfish,350,0 +roastedfish,350,0 +roastfish,350,0 +rofish,350,0 +cookedsalmonfish,350,1 +cooksalmonfish,350,1 +csalmonfish,350,1 +grilledsalmonfish,350,1 +grillsalmonfish,350,1 +gsalmonfish,350,1 +roastedsalmonfish,350,1 +roastsalmonfish,350,1 +rosalmonfish,350,1 +cookedsalmon,350,1 +cooksalmon,350,1 +csalmon,350,1 +grilledsalmon,350,1 +grillsalmon,350,1 +gsalmon,350,1 +roastedsalmon,350,1 +roastsalmon,350,1 +rosalmon,350,1 +dye,351,0 +inksack,351,0 +inksac,351,0 +isack,351,0 +isac,351,0 +sack,351,0 +sac,351,0 +blackinksack,351,0 +blackinksac,351,0 +blackisack,351,0 +blackisac,351,0 +blacksack,351,0 +blacksac,351,0 +inksackblack,351,0 +inksacblack,351,0 +isackblack,351,0 +isacblack,351,0 +sackblack,351,0 +sacblack,351,0 +blackinksackcolour,351,0 +blackinksaccolour,351,0 +blackisackcolour,351,0 +blackisaccolour,351,0 +blacksackcolour,351,0 +blacksaccolour,351,0 +inksackblackcolour,351,0 +inksacblackcolour,351,0 +isackblackcolour,351,0 +isacclackcolour,351,0 +sackblackcolour,351,0 +sacblackcolour,351,0 +blackinksackcolor,351,0 +blackinksaccolor,351,0 +blackisackcolor,351,0 +blackisaccolor,351,0 +blacksackcolor,351,0 +blacksaccolor,351,0 +inksackblackcolor,351,0 +inksacblackcolor,351,0 +isackblackcolor,351,0 +isacblackcolor,351,0 +sackblackcolor,351,0 +sacblackcolor,351,0 +blackinksackdye,351,0 +blackinksacdye,351,0 +blackisackdye,351,0 +blackisacdye,351,0 +blacksackdye,351,0 +blacksacdye,351,0 +inksackblackdye,351,0 +inksacblackdye,351,0 +isackblackdye,351,0 +isacclackdye,351,0 +sackblackdye,351,0 +sacblackdye,351,0 +blackcolor,351,0 +blackdye,351,0 +rosered,351,1 +roseredcolor,351,1 +roseredcolour,351,1 +rosereddye,351,1 +redrosecolor,351,1 +redrosecolour,351,1 +redrosedye,351,1 +redr,351,1 +redrcolor,351,1 +redrcolour,351,1 +redrdye,351,1 +redcolor,351,1 +redcolour,351,1 +reddye,351,1 +cactusgreen,351,2 +greencactus,351,2 +cactusgreencolour,351,2 +greencactuscolour,351,2 +cactusgreencolor,351,2 +greencactuscolor,351,2 +cactusgreendye,351,2 +greencactusdye,351,2 +greencolour,351,2 +greencolor,351,2 +greendye,351,2 +cocoabeans,351,3 +cocoabean,351,3 +cocobeans,351,3 +cocobean,351,3 +cbeans,351,3 +cbean,351,3 +beans,351,3 +bean,351,3 +browncocoabeans,351,3 +browncocoabean,351,3 +browncocobeans,351,3 +browncocobean,351,3 +browncbeans,351,3 +browncbean,351,3 +brownbeans,351,3 +brownbean,351,3 +brownb,351,3 +cocoabeanscolour,351,3 +cocoabeancolour,351,3 +cocobeanscolour,351,3 +cocobeancolour,351,3 +cbeanscolour,351,3 +cbeancolour,351,3 +beanscolour,351,3 +beancolour,351,3 +browncocoabeanscolour,351,3 +browncocoabeancolour,351,3 +browncocobeanscolour,351,3 +browncocobeancolour,351,3 +browncbeanscolour,351,3 +browncbeancolour,351,3 +brownbeanscolour,351,3 +brownbeancolour,351,3 +brownbcolour,351,3 +cocoabeanscolor,351,3 +cocoabeancolor,351,3 +cocobeanscolor,351,3 +cocobeancolor,351,3 +cbeanscolor,351,3 +cbeancolor,351,3 +beanscolor,351,3 +beancolor,351,3 +browncocoabeanscolor,351,3 +browncocoabeancolor,351,3 +browncocobeanscolor,351,3 +browncocobeancolor,351,3 +browncbeanscolor,351,3 +browncbeancolor,351,3 +brownbeanscolor,351,3 +brownbeancolor,351,3 +brownbcolor,351,3 +cocoabeansdye,351,3 +cocoabeandye,351,3 +cocobeansdye,351,3 +cocobeandye,351,3 +cbeansdye,351,3 +cbeandye,351,3 +beansdye,351,3 +beandye,351,3 +browncocoabeansdye,351,3 +browncocoabeandye,351,3 +browncocobeansdye,351,3 +browncocobeandye,351,3 +browncbeansdye,351,3 +browncbeandye,351,3 +brownbeansdye,351,3 +brownbeandye,351,3 +brownbdye,351,3 +browncolour,351,3 +browncolor,351,3 +browndye,351,3 +lapislazuli,351,4 +bluelapislazuli,351,4 +bluelapisl,351,4 +bluelapis,351,4 +bluel,351,4 +lapislazuliblue,351,4 +lapislblue,351,4 +lapisblue,351,4 +lapisl,351,4 +lapis,351,4 +bluelapislazulicolour,351,4 +bluelapislcolour,351,4 +bluelapiscolour,351,4 +lapislazulibluecolour,351,4 +lapislbluecolour,351,4 +lapisbluecolour,351,4 +lapislazulicolour,351,4 +lapislcolour,351,4 +lapiscolour,351,4 +bluelapislazulicolor,351,4 +bluelapislcolor,351,4 +bluelapiscolor,351,4 +lapislazulibluecolor,351,4 +lapislbluecolor,351,4 +lapisbluecolor,351,4 +lapislazulicolor,351,4 +lapislcolor,351,4 +lapiscolor,351,4 +bluelapislazulidye,351,4 +bluelapisldye,351,4 +bluelapisdye,351,4 +lapislazulibluedye,351,4 +lapislbluedye,351,4 +lapisbluedye,351,4 +lapislazulidye,351,4 +lapisldye,351,4 +lapisdye,351,4 +bluecolour,351,4 +bluecolor,351,4 +bluedye,351,4 +purpledye,351,5 +purplecolour,351,5 +purplecolor,351,5 +cyandye,351,6 +cyancolour,351,6 +cyancolor,351,6 +lightgraydye,351,7 +lightgraycolour,351,7 +lightgraycolor,351,7 +lgraycolour,351,7 +lgraycolor,351,7 +lgraydye,351,7 +lightgreydye,351,7 +lightgreycolour,351,7 +lightgreycolor,351,7 +lgreycolour,351,7 +lgreycolor,351,7 +lgreydye,351,7 +silvercolour,351,7 +silvercolor,351,7 +silverdye,351,7 +darkgraydye,351,8 +darkgraycolour,351,8 +darkgraycolor,351,8 +dgraycolour,351,8 +dgraycolor,351,8 +dgraydye,351,8 +graycolour,351,8 +graycolor,351,8 +graydye,351,8 +darkgreydye,351,8 +darkgreycolour,351,8 +darkgreycolor,351,8 +dgreycolour,351,8 +dgreycolor,351,8 +dgreydye,351,8 +greycolour,351,8 +greycolor,351,8 +greydye,351,8 +pinkdye,351,9 +pinkcolour,351,9 +pinkcolor,351,9 +limedye,351,10 +limecolour,351,10 +limecolor,351,10 +dandelionyellow,351,11 +dandelionyellowcolour,351,11 +dandelionyellowcolor,351,11 +dandelionyellowdye,351,11 +yellowdandelioncolour,351,11 +yellowdandelioncolor,351,11 +yellowdandeliondye,351,11 +yellowd,351,11 +yellowdcolour,351,11 +yellowdcolor,351,11 +yellowddye,351,11 +dyellow,351,11 +dyellowcolour,351,11 +dyellowcolor,351,11 +dyellowdye,351,11 +yellowcolour,351,11 +yellowcolor,351,11 +yellowdye,351,11 +lightbluecolour,351,12 +lightbluecolor,351,12 +lightbluedye,351,12 +lbluecolour,351,12 +lbluecolor,351,12 +lbluedye,351,12 +magentacolour,351,13 +magentacolor,351,13 +magentadye,351,13 +orangecolour,351,14 +orangecolor,351,14 +orangedye,351,14 +bonemeal,351,15 +whitebonemeal,351,15 +whitebonemealcolour,351,15 +whitebonemealcolor,351,15 +whitebonemealdye,351,15 +bonemealwhite,351,15 +bonemealwhitecolour,351,15 +bonemealwhitecolor,351,15 +bonemealwhitedye,351,15 +whitebonem,351,15 +whitebonemcolour,351,15 +whitebonemcolor,351,15 +whitebonemdye,351,15 +bonemwhite,351,15 +bonemwhitecolour,351,15 +bonemwhitecolor,351,15 +bonemwhitedye,351,15 +bonemealcolour,351,15 +bonemealcolor,351,15 +bonemealdye,351,15 +bonem,351,15 +bonemcolour,351,15 +bonemcolor,351,15 +bonemdye,351,15 +whitecolour,351,15 +whitecolor,351,15 +whitedye,351,15 +bone,352,0 +sugar,353,0 +whitedust,353,0 +cake,354,0 +bed,355 +whitebed,355,0 +wbed,355,0 +orangebed,355,1 +obed,355,1 +magentabed,355,2 +mbed,355,2 +lightbluebed,355,3 +lightblubed,355,3 +lbluebed,355,3 +lblubed,355,3 +lbbed,355,3 +yellowbed,355,4 +ybed,355,4 +lightgreenbed,355,5 +lgreenbed,355,5 +lightgrebed,355,5 +lgrebed,355,5 +limebed,355,5 +lbed,355,5 +pinkbed,355,6 +pibed,355,6 +darkgraybed,355,7 +dgraybed,355,7 +darkgreybed,355,7 +dgreybed,355,7 +darkgrabed,355,7 +dgrabed,355,7 +graybed,355,7 +greybed,355,7 +grabed,355,7 +lgbed,355,8 +lightgraybed,355,8 +lgraybed,355,8 +lightgreybed,355,8 +lgreybed,355,8 +lightgrabed,355,8 +lgrabed,355,8 +silverbed,355,8 +sibed,355,8 +cyanbed,355,9 +cbed,355,9 +purplebed,355,10 +pubed,355,10 +bluebed,355,11 +blubed,355,11 +brownbed,355,12 +brobed,355,12 +darkgreenbed,355,13 +dgreenbed,355,13 +greenbed,355,13 +darkgrebed,355,13 +dgrebed,355,13 +grebed,355,13 +redbed,355,14 +rbed,355,14 +blackbed,355,15 +blabed,355,15 +redstonerepeater,356,0 +redstonerepeat,356,0 +redstonedelayer,356,0 +redstonedelay,356,0 +redstonedioder,356,0 +redstonediode,356,0 +rstonerepeater,356,0 +rstonerepeat,356,0 +rstonedelayer,356,0 +rstonedelay,356,0 +rstonedioder,356,0 +rstonediode,356,0 +redsrepeater,356,0 +redsrepeat,356,0 +redsdelayer,356,0 +redsdelay,356,0 +redsdioder,356,0 +redsdiode,356,0 +rsrepeater,356,0 +rsrepeat,356,0 +rsdelayer,356,0 +rsdelay,356,0 +rsdioder,356,0 +rsdiode,356,0 +repeater,356,0 +repeat,356,0 +delayer,356,0 +delay,356,0 +dioder,356,0 +diode,356,0 +cookie,357,0 +chart,358,0 +map0,358,0 +map1,358,1 +map2,358,2 +map3,358,3 +map4,358,4 +map5,358,5 +map6,358,6 +map7,358,7 +map8,358,8 +map9,358,9 +map10,358,10 +map11,358,11 +map12,358,12 +map13,358,13 +map14,358,14 +map15,358,15 +shears,359,0 +shear,359,0 +sheers,359,0 +sheer,359,0 +woolcutters,359,0 +woolcutter,359,0 +cutterswool,359,0 +cutterwool,359,0 +melonslice,360,0 +mslice,360,0 +slicemelon,360,0 +watermelonslice,360,0 +greenmelonslice,360,0 +melongreenslice,360,0 +pumpkinseeds,361,0 +pseeds,361,0 +seedsp,361,0 +seedspumpkin,361,0 +pumpseeds,361,0 +seedspump,361,0 +melonseeds,362,0 +mseeds,362,0 +watermelonseeds,362,0 +greenmelonseeds,362,0 +gmelonseeds,362,0 +seedsmelon,362,0 +seedswatermelon,362,0 +rawbeef,363,0 +rawsteak,363,0 +uncookedbeef,363,0 +uncookedsteak,363,0 +cowmeat,363,0 +plainbeef,363,0 +beef,364,0 +steak,364,0 +cookedbeef,364,0 +grilledbeef,364,0 +cookedsteak,364,0 +grilledsteak,364,0 +cookedcowmeat,364,0 +rawchicken,365,0 +uncookedchicken,365,0 +plainchicken,365,0 +chickenplain,365,0 +chickenuncooked,365,0 +chickenraw,365,0 +cookedchicken,366,0 +grilledchicken,366,0 +toastedchicken,366,0 +gchicken,366,0 +bbqchicken,366,0 +friedchicken,366,0 +cchicken,366,0 +rottenflesh,367,0 +zombieflesh,367,0 +rottenmeat,367,0 +zombiemeat,367,0 +badflesh,367,0 +poisonflesh,367,0 +zombieremains,367,0 +enderpearl,368,0 +endpearl,368,0 +pearl,368,0 +epearl,368,0 +bluepearl,368,0 +endergem,368,0 +blazerod,369,0 +goldenrod,369,0 +goldrod,369,0 +blazestick,369,0 +goldstick,369,0 +brod,369,0 +grod,369,0 +bstick,369,0 +gstick,369,0 +ghasttear,370,0 +ghastdrop,370,0 +ghosttear,370,0 +ghostdrop,370,0 +gtear,370,0 +gdrop,370,0 +tear,370,0 +goldnugget,371,0 +gnugget,371,0 +goldpebble,371,0 +gpebble,371,0 +goldball,371,0 +gball,371,0 +netherstalk,372,0 +deathstalk,372,0 +hellstalk,372,0 +nstalk,372,0 +dstalk,372,0 +hstalk,372,0 +netherwarts,372,0 +netherwart,372,0 +netherplant,372,0 +nethercrop,372,0 +hellwarts,372,0 +hellwart,372,0 +hellplant,372,0 +hellcrop,372,0 +deathwarts,372,0 +deathwart,372,0 +deathplant,372,0 +deathcrop,372,0 +nwarts,372,0 +nwart,372,0 +ncrop,372,0 +nplant,372,0 +hwarts,372,0 +hwart,372,0 +hplant,372,0 +hcrop,372,0 +dwarts,372,0 +dwart,372,0 +dplant,372,0 +dcrop,372,0 +potion,373,0 +mixture,373,0 +potions,373,0 +waterbottle,373,0 +fullbottle,373,0 +watervase,373,0 +fullvase,373,0 +clearpotion,373,6 +clearpot,373,6 +clearextendedpotion,373,7 +clearexpotion,373,7 +clear2potion,373,7 +clearextendedpot,373,7 +clearexpot,373,7 +clear2pot,373,7 +diffusepotion,373,11 +diffusepot,373,11 +artlesspotion,373,13 +artlesspot,373,13 +thinpotion,373,14 +thinpot,373,14 +thinextendedpotion,373,15 +thinexpotion,373,15 +thin2potion,373,15 +thinextendedpot,373,15 +thinexpot,373,15 +thin2pot,373,15 +awkwardpotion,373,16 +awkwardpot,373,16 +bunglingpotion,373,22 +bunglingpot,373,22 +bunglingextendedpotion,373,23 +bunglingexpotion,373,23 +bungling2potion,373,23 +bunglingextendedpot,373,23 +bunglingexpot,373,23 +bungling2pot,373,23 +smoothpotion,373,27 +smoothpot,373,27 +suavepotion,373,29 +suavepot,373,29 +debonairpotion,373,30 +debonairpot,373,30 +debonairextendedpotion,373,31 +debonairexpotion,373,31 +debonair2potion,373,31 +debonairextendedpot,373,31 +debonairexpot,373,31 +debonair2pot,373,31 +thickpotion,373,32 +thickpot,373,32 +charmingpotion,373,38 +charmingpot,373,38 +charmingextendedpotion,373,39 +charmingexpotion,373,39 +charming2potion,373,39 +charmingextendedpot,373,39 +charmingexpot,373,39 +charming2pot,373,39 +refinedpotion,373,43 +refinedpot,373,43 +cordialpotion,373,45 +cordialpot,373,45 +sparklingpotion,373,46 +sparklingpot,373,46 +sparklingextendedpotion,373,47 +sparklingexpotion,373,47 +sparkling2potion,373,47 +sparklingextendedpot,373,47 +sparklingexpot,373,47 +sparkling2pot,373,47 +potentpotion,373,48 +potentpot,373,48 +rankpotion,373,54 +rankpot,373,54 +rankextendedpotion,373,55 +rankexpotion,373,55 +rank2potion,373,55 +rankextendedpot,373,55 +rankexpot,373,55 +rank2pot,373,55 +acridpotion,373,59 +acridpot,373,59 +grosspotion,373,61 +grosspot,373,61 +stinkypotion,373,62 +stinkypot,373,62 +stinkyextendedpotion,373,63 +stinkyexpotion,373,63 +stinky2potion,373,63 +stinkyextendedpot,373,63 +stinkyexpot,373,63 +stinky2pot,373,63 +mundaneextendedpotion,373,64 +mundaneexpotion,373,64 +mundane2potion,373,64 +mundaneextendedpot,373,64 +mundaneexpot,373,64 +mundane2pot,373,64 +mundanepotion,373,8192 +mundanepot,373,8192 +regenerationpotion,373,8193 +regeneratepotion,373,8193 +regenpotion,373,8193 +regenerationpot,373,8193 +regeneratepot,373,8193 +regenpot,373,8193 +rpot,373,8193 +swiftnesspotion,373,8194 +swiftpotion,373,8194 +speedpotion,373,8194 +swiftnesspot,373,8194 +swiftpot,373,8194 +speedpot,373,8194 +swpot,373,8194 +fireresistancepotion,373,8195 +fireresistpotion,373,8195 +firerespotion,373,8195 +fireresistancepot,373,8195 +fireresistpot,373,8195 +firerespot,373,8195 +fpot,373,8195 +poisonpotion,373,8196 +acidpotion,373,8196 +poisonpot,373,8196 +acidpot,373,8196 +ppot,373,8196 +healingpotion,373,8197 +healpotion,373,8197 +lifepotion,373,8197 +healingpot,373,8197 +healpot,373,8197 +lifepot,373,8197 +hpot,373,8197 +nightvisionpotion,373,8198 +nvisionpotion,373,8198 +nightvpotion,373,8198 +darkvisionpotion,373,8198 +dvisionpotion,373,8198 +darkvpotion,373,8198 +nightvisionpot,373,8198 +nvisionpot,373,8198 +nightvpot,373,8198 +darkvisionpot,373,8198 +dvisionpot,373,8198 +darkvpot,373,8198 +npot,373,8198 +weaknesspotion,373,8200 +weakpotion,373,8200 +weaknesspot,373,8200 +weakpot,373,8200 +wpot,373,8200 +strengthpotion,373,8201 +strongpotion,373,8201 +strpotion,373,8201 +strengthpot,373,8201 +strongpot,373,8201 +strpot,373,8201 +stpot,373,8201 +slownesspotion,373,8202 +slowpotion,373,8202 +slownesspot,373,8202 +slowpot,373,8202 +slpot,373,8202 +harmingpotion,373,8204 +damagepotion,373,8204 +dmgpotion,373,8204 +harmingpot,373,8204 +damagepot,373,8204 +dmgpot,373,8204 +dpot,373,8204 +waterbreathingpotion,373,8205 +waterbreathpotion,373,8205 +breathingpotion,373,8205 +breathpotion,373,8205 +waterbreathingpot,373,8205 +waterbreathpot,373,8205 +breathingpot,373,8205 +breathpot,373,8205 +wbpot,373,8205 +invisibilitypotion,373,8206 +invisiblepotion,373,8206 +invpotion,373,8206 +invisibilitypot,373,8206 +invisiblepot,373,8206 +invpot,373,8206 +ipot,373,8206 +regenerationleveliipotion,373,8225 +regenerateleveliipotion,373,8225 +regenleveliipotion,373,8225 +regenerationlevel2potion,373,8225 +regeneratelevel2potion,373,8225 +regenlevel2potion,373,8225 +regenerationiipotion,373,8225 +regenerateiipotion,373,8225 +regeniipotion,373,8225 +regenerationleveliipot,373,8225 +regenerateleveliipot,373,8225 +regenleveliipot,373,8225 +regenerationlevel2pot,373,8225 +regeneratelevel2pot,373,8225 +regenlevel2pot,373,8225 +regenerationiipot,373,8225 +regenerateiipot,373,8225 +regeniipot,373,8225 +r2pot,373,8225 +swiftnessleveliipotion,373,8226 +swiftleveliipotion,373,8226 +speedleveliipotion,373,8226 +swiftnesslevel2potion,373,8226 +swiftlevel2potion,373,8226 +speedlevel2potion,373,8226 +swiftnessiipotion,373,8226 +swiftiipotion,373,8226 +speediipotion,373,8226 +swiftnessleveliipot,373,8226 +swiftleveliipot,373,8226 +speedleveliipot,373,8226 +swiftnesslevel2pot,373,8226 +swiftlevel2pot,373,8226 +speedlevel2pot,373,8226 +swiftnessiipot,373,8226 +swiftiipot,373,8226 +speediipot,373,8226 +sw2pot,373,8226 +poisonleveliipotion,373,8228 +acidleveliipotion,373,8228 +poisonlevel2potion,373,8228 +acidlevel2potion,373,8228 +poisoniipotion,373,8228 +acidiipotion,373,8228 +poisonleveliipot,373,8228 +acidleveliipot,373,8228 +poisonlevel2pot,373,8228 +acidlevel2pot,373,8228 +poisoniipot,373,8228 +acidiipot,373,8228 +p2pot,373,8228 +healingleveliipotion,373,8229 +healleveliipotion,373,8229 +healinglevel2potion,373,8229 +heallevel2potion,373,8229 +healingiipotion,373,8229 +healiipotion,373,8229 +healingleveliipot,373,8229 +healleveliipot,373,8229 +healinglevel2pot,373,8229 +heallevel2pot,373,8229 +healingiipot,373,8229 +healiipot,373,8229 +h2pot,373,8229 +strengthleveliipotion,373,8233 +strongleveliipotion,373,8233 +strleveliipotion,373,8233 +strengthlevel2potion,373,8233 +stronglevel2potion,373,8233 +strlevel2potion,373,8233 +strengthiipotion,373,8233 +strongiipotion,373,8233 +striipotion,373,8233 +strengthleveliipot,373,8233 +strongleveliipot,373,8233 +strleveliipot,373,8233 +strengthlevel2pot,373,8233 +stronglevel2pot,373,8233 +strlevel2pot,373,8233 +strengthiipot,373,8233 +strongiipot,373,8233 +striipot,373,8233 +st2pot,373,8233 +leapingleveliipotion,373,8235 +leapleveliipotion,373,8235 +leaplevel2potion,373,8235 +leapinglevel2potion,373,8235 +leapingiipotion,373,8235 +leapiipotion,373,8235 +leapiipotion,373,8235 +leapingiipotion,373,8235 +leap2potion,373,8235 +leaping2potion,373,8235 +harmingleveliipotion,373,8236 +damageleveliipotion,373,8236 +dmgleveliipotion,373,8236 +harminglevel2potion,373,8236 +damagelevel2potion,373,8236 +dmglevel2potion,373,8236 +harmingiipotion,373,8236 +damageiipotion,373,8236 +dmgiipotion,373,8236 +harmingleveliipot,373,8236 +damageleveliipot,373,8236 +dmgleveliipot,373,8236 +harminglevel2pot,373,8236 +damagelevel2pot,373,8236 +dmglevel2pot,373,8236 +harmingiipot,373,8236 +damageiipot,373,8236 +dmgiipot,373,8236 +d2pot,373,8236 +regenerationextendedpotion,373,8257 +regenerateextendedpotion,373,8257 +regenextendepotion,373,8257 +regenerationexpotion,373,8257 +regenerateexpotion,373,8257 +regenexpotion,373,8257 +regenerationextendedpot,373,8257 +regenerateextendedpot,373,8257 +regenextendepot,373,8257 +regenerationexpot,373,8257 +regenerateexpot,373,8257 +regenexpot,373,8257 +repot,373,8257 +swiftnessextendedpotion,373,8258 +swiftextendedpotion,373,8258 +speedextendedpotion,373,8258 +swiftnessexpotion,373,8258 +swiftexpotion,373,8258 +speedexpotion,373,8258 +swiftnessextendedpot,373,8258 +swiftextendedpot,373,8258 +speedextendedpot,373,8258 +swiftnessexpot,373,8258 +swiftexpot,373,8258 +speedexpot,373,8258 +swepot,373,8258 +fireresistancepotion,373,8227 +fireresistpotion,373,8227 +firerespotion,373,8227 +fireresistpotion,373,8227 +fireresistancepot,373,8227 +fireresistpot,373,8227 +firerespot,373,8227 +frpot,373,8227 +fireresistanceextendedpotion,373,8259 +fireresistextendedpotion,373,8259 +fireresextendedpotion,373,8259 +fireresistanceexpotion,373,8259 +fireresistexpotion,373,8259 +fireresexpotion,373,8259 +fireresistanceextendedpot,373,8259 +fireresistextendedpot,373,8259 +fireresextendedpot,373,8259 +fireresistanceexpot,373,8259 +fireresistexpot,373,8259 +fireresexpot,373,8259 +fepot,373,8259 +poisonextendedpotion,373,8260 +acidextendedpotion,373,8260 +poisonexpotion,373,8260 +acidexpotion,373,8260 +poisonextendedpot,373,8260 +acidextendedpot,373,8260 +poisonexpot,373,8260 +acidexpot,373,8260 +pepot,373,8260 +nightvisionextendedpotion,373,8262 +nvisionextendedpotion,373,8262 +nightvextendedpotion,373,8262 +darkvisionextendedpotion,373,8262 +dvisionextendedpotion,373,8262 +darkvextendedpotion,373,8262 +nightvisionexpotion,373,8262 +nvisionexpotion,373,8262 +nightvexpotion,373,8262 +darkvisionexpotion,373,8262 +dvisionexpotion,373,8262 +darkvexpotion,373,8262 +nightvisionextendedpot,373,8262 +nvisionextendedpot,373,8262 +nightvextendedpot,373,8262 +darkvisionextendedpot,373,8262 +dvisionextendedpot,373,8262 +darkvextendedpot,373,8262 +nightvisionexpot,373,8262 +nvisionexpot,373,8262 +nightvexpot,373,8262 +darkvisionexpot,373,8262 +dvisionexpot,373,8262 +darkvexpot,373,8262 +nepot,373,8262 +weaknessextendedpotion,373,8264 +weakextendedpotion,373,8264 +weaknessexpotion,373,8264 +weakexpotion,373,8264 +weaknessextendedpot,373,8264 +weakextendedpot,373,8264 +weaknessexpot,373,8264 +weakexpot,373,8264 +wepot,373,8264 +strengthextendedpotion,373,8265 +strongextendedpotion,373,8265 +strextendedpotion,373,8265 +strengthexpotion,373,8265 +strongexpotion,373,8265 +strexpotion,373,8265 +strengthextendedpot,373,8265 +strongextendedpot,373,8265 +strextendedpot,373,8265 +strengthexpot,373,8265 +strongexpot,373,8265 +strexpot,373,8265 +stepot,373,8265 +slownessextendedpotion,373,8266 +slowextenedpotion,373,8266 +slownessexpotion,373,8266 +slowexpotion,373,8266 +slownessextendedpot,373,8266 +slowextenedpot,373,8266 +slownessexpot,373,8266 +slowexpot,373,8266 +slepot,373,8266 +leapingpotion,373,8267 +leappotion,373,8267 +waterbreathingextendedpotion,373,8269 +waterbreathextendedpotion,373,8269 +breathingextendedpotion,373,8269 +breathextendedpotion,373,8269 +waterbreathingextendedpot,373,8269 +waterbreathextendedpot,373,8269 +breathingextendedpot,373,8269 +breathextendedpot,373,8269 +waterbreathingexpotion,373,8269 +waterbreathexpotion,373,8269 +breathingexpotion,373,8269 +breathexpotion,373,8269 +waterbreathingexpot,373,8269 +waterbreathexpot,373,8269 +breathingexpot,373,8269 +breathexpot,373,8269 +wbepot,373,8269 +invisibilityextendedpotion,373,8270 +invisibleextendedpotion,373,8270 +invextendedpotion,373,8270 +invisibilityexpotion,373,8270 +invisibleexpotion,373,8270 +invexpotion,373,8270 +invisibilityextendedpot,373,8270 +invisibleextendedpot,373,8270 +invextendedpot,373,8270 +invisibilityexpot,373,8270 +invisibleexpot,373,8270 +invexpot,373,8270 +iepot,373,8270 +regenerationdualbitpotion,373,8289 +regeneratedualbitpotion,373,8289 +regendualbitpotion,373,8289 +regenerationdbpotion,373,8289 +regeneratedbpotion,373,8289 +regendbpotion,373,8289 +regenerationdualbitpot,373,8289 +regeneratedualbitpot,373,8289 +regendualbitpot,373,8289 +regenerationdbpot,373,8289 +regeneratedbpot,373,8289 +regendbpot,373,8289 +rdbpot,373,8289 +swiftnessdualbitpotion,373,8290 +swiftdualbitpotion,373,8290 +speeddualbitpotion,373,8290 +swiftnessdualbitpot,373,8290 +swiftdualbitpot,373,8290 +speeddualbitpot,373,8290 +swiftnessdbpotion,373,8290 +swiftdbpotion,373,8290 +speeddbpotion,373,8290 +swiftnessdbpot,373,8290 +swiftdbpot,373,8290 +speeddbpot,373,8290 +swdbpot,373,8290 +poisondualbitpotion,373,8292 +aciddualbitpotion,373,8292 +poisondualbitpot,373,8292 +aciddualbitpot,373,8292 +poisondbpotion,373,8292 +aciddbpotion,373,8292 +poisondbpot,373,8292 +aciddbpot,373,8292 +pdbpot,373,8292 +strengthdualbitpotion,373,8297 +strongdualbitpotion,373,8297 +strdualbitpotion,373,8297 +strengthdualbitpot,373,8297 +strongdualbitpot,373,8297 +strdualbitpot,373,8297 +strengthdbpotion,373,8297 +strongdbpotion,373,8297 +strdbpotion,373,8297 +strengthdbpot,373,8297 +strongdbpot,373,8297 +strdbpot,373,8297 +stdbpot,373,8297 +splashmundanepotion,373,16384 +splmundanepotion,373,16384 +splashregenerationpotion,373,16385 +splashregeneratepotion,373,16385 +splashregenpotion,373,16385 +splashregenerationpot,373,16385 +splashregeneratepot,373,16385 +splashregenpot,373,16385 +regenerationsplashpotion,373,16385 +regeneratesplashpotion,373,16385 +regensplashpotion,373,16385 +splregenerationpotion,373,16385 +splregeneratepotion,373,16385 +splregenpotion,373,16385 +splregenerationpot,373,16385 +splregeneratepot,373,16385 +splregenpot,373,16385 +sprpot,373,16385 +splashswiftnesspotion,373,16386 +splashswiftpotion,373,16386 +splashspeedpotion,373,16386 +splashswiftnesspot,373,16386 +splashswiftpot,373,16386 +splashspeedpot,373,16386 +splswiftnesspotion,373,16386 +splswiftpotion,373,16386 +splspeedpotion,373,16386 +splswiftnesspot,373,16386 +splswiftpot,373,16386 +splspeedpot,373,16386 +spswpot,373,16386 +splashfireresistancepotion,373,16387 +splashfireresistpotion,373,16387 +splashfirerespotion,373,16387 +splashfireresistancepot,373,16387 +splashfireresistpot,373,16387 +splashfirerespot,373,16387 +splfireresistancepotion,373,16387 +splfireresistpotion,373,16387 +splfirerespotion,373,16387 +splfireresistancepot,373,16387 +splfireresistpot,373,16387 +splfirerespot,373,16387 +spfpot,373,16387 +splashpoisonpotion,373,16388 +splashacidpotion,373,16388 +splashpoisonpot,373,16388 +splashacidpot,373,16388 +splpoisonpotion,373,16388 +splacidpotion,373,16388 +splpoisonpot,373,16388 +splacidpot,373,16388 +spppot,373,16388 +splashhealingpotion,373,16389 +splashhealpotion,373,16389 +splashlifepotion,373,16389 +splashhealingpot,373,16389 +splashhealpot,373,16389 +splashlifepot,373,16389 +splhealingpotion,373,16389 +splhealpotion,373,16389 +spllifepotion,373,16389 +splhealingpot,373,16389 +splhealpot,373,16389 +spllifepot,373,16389 +sphpot,373,16389 +splashclearpotion,373,16390 +splashclearpot,373,16390 +splclearpotion,373,16390 +splclearpot,373,16390 +splashnightvisionpotion,373,16390 +splashnvisionpotion,373,16390 +splashnightvpotion,373,16390 +splashdarkvisionpotion,373,16390 +splashdvisionpotion,373,16390 +splashdarkvpotion,373,16390 +splashnightvisionpot,373,16390 +splashnvisionpot,373,16390 +splashnightvpot,373,16390 +splashdarkvisionpot,373,16390 +splashdvisionpot,373,16390 +splashdarkvpot,373,16390 +splnightvisionpotion,373,16390 +splnvisionpotion,373,16390 +splnightvpotion,373,16390 +spldarkvisionpotion,373,16390 +spldvisionpotion,373,16390 +spldarkvpotion,373,16390 +splnightvisionpot,373,16390 +splnvisionpot,373,16390 +splnightvpot,373,16390 +spldarkvisionpot,373,16390 +spldvisionpot,373,16390 +spldarkvpot,373,16390 +spnpot,373,16390 +splashclearextendedpotion,373,16391 +splashclearexpotion,373,16391 +splashclear2potion,373,16391 +splashclearextendedpot,373,16391 +splashclearexpot,373,16391 +splashclear2pot,373,16391 +splclearextendedpotion,373,16391 +splclearexpotion,373,16391 +splclear2potion,373,16391 +splclearextendedpot,373,16391 +splclearexpot,373,16391 +splclear2pot,373,16391 +splashweaknesspotion,373,16392 +splashweakpotion,373,16392 +splashweaknesspot,373,16392 +splashweakpot,373,16392 +splweaknesspotion,373,16392 +splweakpotion,373,16392 +splweaknesspot,373,16392 +splweakpot,373,16392 +spwpot,373,16392 +splashstrengthpotion,373,16393 +splashstrongpotion,373,16393 +splashstrpotion,373,16393 +splashstrengthpot,373,16393 +splashstrongpot,373,16393 +splashstrpot,373,16393 +splstrengthpotion,373,16393 +splstrongpotion,373,16393 +splstrpotion,373,16393 +splstrengthpot,373,16393 +splstrongpot,373,16393 +splstrpot,373,16393 +spstpot,373,16393 +splashslownesspotion,373,16394 +splashslowpotion,373,16394 +splashslownesspot,373,16394 +splashslowpot,373,16394 +splslownesspotion,373,16394 +splslowpotion,373,16394 +splslownesspot,373,16394 +splslowpot,373,16394 +spslpot,373,16394 +splashdiffusepotion,373,16395 +splashdiffusepot,373,16395 +spldiffusepotion,373,16395 +spldiffusepot,373,16395 +splashharmingpotion,373,16396 +splashdamagepotion,373,16396 +splashdmgpotion,373,16396 +splashharmingpot,373,16396 +splashdamagepot,373,16396 +splashdmgpot,373,16396 +splharmingpotion,373,16396 +spldamagepotion,373,16396 +spldmgpotion,373,16396 +splharmingpot,373,16396 +spldamagepot,373,16396 +spldmgpot,373,16396 +spdpot,373,16396 +splashartlesspotion,373,16397 +splashartlesspot,373,16397 +splartlesspotion,373,16397 +splartlesspot,373,16397 +splashwaterbreathingpotion,373,16397 +splashwaterbreathpotion,373,16397 +splashbreathingpotion,373,16397 +splashbreathpotion,373,16397 +splashwaterbreathingpot,373,16397 +splashwaterbreathpot,373,16397 +splashbreathingpot,373,16397 +splashbreathpot,373,16397 +splwaterbreathingpotion,373,16397 +splwaterbreathpotion,373,16397 +splbreathingpotion,373,16397 +splbreathpotion,373,16397 +splwaterbreathingpot,373,16397 +splwaterbreathpot,373,16397 +splbreathingpot,373,16397 +splbreathpot,373,16397 +spwbpot,373,16397 +splashthinpotion,373,16398 +splashthinpot,373,16398 +splthinpotion,373,16398 +splthinpot,373,16398 +splashinvisibilitypotion,373,16398 +splashinvisiblepotion,373,16398 +splashinvpotion,373,16398 +splashinvisibilitypot,373,16398 +splashinvisiblepot,373,16398 +splashinvpot,373,16398 +splinvisibilitypotion,373,16398 +splinvisiblepotion,373,16398 +splinvpotion,373,16398 +splinvisibilitypot,373,16398 +splinvisiblepot,373,16398 +splinvpot,373,16398 +spipot,373,16398 +splashthinextendedpotion,373,16399 +splashthinexpotion,373,16399 +splashthin2potion,373,16399 +splashthinextendedpot,373,16399 +splashthinexpot,373,16399 +splashthin2pot,373,16399 +splthinextendedpotion,373,16399 +splthinexpotion,373,16399 +splthin2potion,373,16399 +splthinextendedpot,373,16399 +splthinexpot,373,16399 +splthin2pot,373,16399 +splashawkwardpotion,373,16400 +splashawkwardpot,373,16400 +splawkwardpotion,373,16400 +splawkwardpot,373,16400 +splashbunglingpotion,373,16406 +splashbunglingpot,373,16406 +splbunglingpotion,373,16406 +splbunglingpot,373,16406 +splashbunglingextendedpotion,373,16407 +splashbunglingexpotion,373,16407 +splashbungling2potion,373,16407 +splashbunglingextendedpot,373,16407 +splashbunglingexpot,373,16407 +splashbungling2pot,373,16407 +splbunglingextendedpotion,373,16407 +splbunglingexpotion,373,16407 +splbungling2potion,373,16407 +splbunglingextendedpot,373,16407 +splbunglingexpot,373,16407 +splbungling2pot,373,16407 +splashsmoothpotion,373,16411 +splashsmoothpot,373,16411 +splsmoothpotion,373,16411 +splsmoothpot,373,16411 +splashsuavepotion,373,16413 +splashsuavepot,373,16413 +splsuavepotion,373,16413 +splsuavepot,373,16413 +splashdebonairpotion,373,16414 +splashdebonairpot,373,16414 +spldebonairpotion,373,16414 +spldebonairpot,373,16414 +splashdebonairextendedpotion,373,16415 +splashdebonairexpotion,373,16415 +splashdebonair2potion,373,16415 +splashdebonairextendedpot,373,16415 +splashdebonairexpot,373,16415 +splashdebonair2pot,373,16415 +spldebonairextendedpotion,373,16415 +spldebonairexpotion,373,16415 +spldebonair2potion,373,16415 +spldebonairextendedpot,373,16415 +spldebonairexpot,373,16415 +spldebonair2pot,373,16415 +splashthickpotion,373,16416 +splashthickpot,373,16416 +splthickpotion,373,16416 +splthickpot,373,16416 +splashregenerationleveliipotion,373,16417 +splashregenerateleveliipotion,373,16417 +splashregenleveliipotion,373,16417 +splashregenerationlevel2potion,373,16417 +splashregeneratelevel2potion,373,16417 +splashregenlevel2potion,373,16417 +splashregenerationiipotion,373,16417 +splashregenerateiipotion,373,16417 +splashregeniipotion,373,16417 +splashregenerationleveliipot,373,16417 +splashregenerateleveliipot,373,16417 +splashregenleveliipot,373,16417 +splashregenerationlevel2pot,373,16417 +splashregeneratelevel2pot,373,16417 +splashregenlevel2pot,373,16417 +splashregenerationiipot,373,16417 +splashregenerateiipot,373,16417 +splashregeniipot,373,16417 +splregenerationleveliipotion,373,16417 +splregenerateleveliipotion,373,16417 +splregenleveliipotion,373,16417 +splregenerationlevel2potion,373,16417 +splregeneratelevel2potion,373,16417 +splregenlevel2potion,373,16417 +splregenerationiipotion,373,16417 +splregenerateiipotion,373,16417 +splregeniipotion,373,16417 +splregenerationleveliipot,373,16417 +splregenerateleveliipot,373,16417 +splregenleveliipot,373,16417 +splregenerationlevel2pot,373,16417 +splregeneratelevel2pot,373,16417 +splregenlevel2pot,373,16417 +splregenerationiipot,373,16417 +splregenerateiipot,373,16417 +splregeniipot,373,16417 +spr2pot,373,16417 +splashswiftnessleveliipotion,373,16418 +splashswiftleveliipotion,373,16418 +splashspeedleveliipotion,373,16418 +splashswiftnesslevel2potion,373,16418 +splashswiftlevel2potion,373,16418 +splashspeedlevel2potion,373,16418 +splashswiftnessiipotion,373,16418 +splashswiftiipotion,373,16418 +splashspeediipotion,373,16418 +splashswiftnessleveliipot,373,16418 +splashswiftleveliipot,373,16418 +splashspeedleveliipot,373,16418 +splashswiftnesslevel2pot,373,16418 +splashswiftlevel2pot,373,16418 +splashspeedlevel2pot,373,16418 +splashswiftnessiipot,373,16418 +splashswiftiipot,373,16418 +splashspeediipot,373,16418 +splswiftnessleveliipotion,373,16418 +splswiftleveliipotion,373,16418 +splspeedleveliipotion,373,16418 +splswiftnesslevel2potion,373,16418 +splswiftlevel2potion,373,16418 +splspeedlevel2potion,373,16418 +splswiftnessiipotion,373,16418 +splswiftiipotion,373,16418 +splspeediipotion,373,16418 +splswiftnessleveliipot,373,16418 +splswiftleveliipot,373,16418 +splspeedleveliipot,373,16418 +splswiftnesslevel2pot,373,16418 +splswiftlevel2pot,373,16418 +splspeedlevel2pot,373,16418 +splswiftnessiipot,373,16418 +splswiftiipot,373,16418 +splspeediipot,373,16418 +spsw2pot,373,16418 +splashpoisonleveliipotion,373,16420 +splashacidleveliipotion,373,16420 +splashpoisonlevel2potion,373,16420 +splashacidlevel2potion,373,16420 +splashpoisoniipotion,373,16420 +splashacidiipotion,373,16420 +splashpoisonleveliipot,373,16420 +splashacidleveliipot,373,16420 +splashpoisonlevel2pot,373,16420 +splashacidlevel2pot,373,16420 +splashpoisoniipot,373,16420 +splashacidiipot,373,16420 +splpoisonleveliipotion,373,16420 +splacidleveliipotion,373,16420 +splpoisonlevel2potion,373,16420 +splcidlevel2potion,373,16420 +splpoisoniipotion,373,16420 +splacidiipotion,373,16420 +splpoisonleveliipot,373,16420 +splacidleveliipot,373,16420 +splpoisonlevel2pot,373,16420 +splacidlevel2pot,373,16420 +splpoisoniipot,373,16420 +splacidiipot,373,16420 +spp2pot,373,16420 +splashhealingleveliipotion,373,16421 +splashhealleveliipotion,373,16421 +splashhealinglevel2potion,373,16421 +splashheallevel2potion,373,16421 +splashhealingiipotion,373,16421 +splashhealiipotion,373,16421 +splashhealingleveliipot,373,16421 +splashhealleveliipot,373,16421 +splashhealinglevel2pot,373,16421 +splashheallevel2pot,373,16421 +splashhealingiipot,373,16421 +splashhealiipot,373,16421 +splhealingleveliipotion,373,16421 +splhealleveliipotion,373,16421 +splhealinglevel2potion,373,16421 +splheallevel2potion,373,16421 +splhealingiipotion,373,16421 +splhealiipotion,373,16421 +splhealingleveliipot,373,16421 +splhealleveliipot,373,16421 +splhealinglevel2pot,373,16421 +splheallevel2pot,373,16421 +splhealingiipot,373,16421 +splhealiipot,373,16421 +sph2pot,373,16421 +splashcharmingpotion,373,16422 +splashcharmingpot,373,16422 +splcharmingpotion,373,16422 +splcharmingpot,373,16422 +splashcharmingextendedpotion,373,16423 +splashcharmingexpotion,373,16423 +splashcharming2potion,373,16423 +splashcharmingextendedpot,373,16423 +splashcharmingexpot,373,16423 +splashcharming2pot,373,16423 +splcharmingextendedpotion,373,16423 +splcharmingexpotion,373,16423 +splcharming2potion,373,16423 +splcharmingextendedpot,373,16423 +splcharmingexpot,373,16423 +splcharming2pot,373,16423 +splashstrengthleveliipotion,373,16425 +splashstrongleveliipotion,373,16425 +splashstrleveliipotion,373,16425 +splashstrengthlevel2potion,373,16425 +splashstronglevel2potion,373,16425 +splashstrlevel2potion,373,16425 +splashstrengthiipotion,373,16425 +splashstrongiipotion,373,16425 +splashstriipotion,373,16425 +splashstrengthleveliipot,373,16425 +splashstrongleveliipot,373,16425 +splashstrleveliipot,373,16425 +splashstrengthlevel2pot,373,16425 +splashstronglevel2pot,373,16425 +splashstrlevel2pot,373,16425 +splashstrengthiipot,373,16425 +splashstrongiipot,373,16425 +splashstriipot,373,16425 +splstrengthleveliipotion,373,16425 +splstrongleveliipotion,373,16425 +splstrleveliipotion,373,16425 +splstrengthlevel2potion,373,16425 +splstronglevel2potion,373,16425 +splstrlevel2potion,373,16425 +splstrengthiipotion,373,16425 +splstrongiipotion,373,16425 +splstriipotion,373,16425 +splstrengthleveliipot,373,16425 +splstrongleveliipot,373,16425 +splstrleveliipot,373,16425 +splstrengthlevel2pot,373,16425 +splstronglevel2pot,373,16425 +splstrlevel2pot,373,16425 +splstrengthiipot,373,16425 +splstrongiipot,373,16425 +splstriipot,373,16425 +spst2pot,373,16425 +splashrefinedpotion,373,16427 +splashrefinedpot,373,16427 +splrefinedpotion,373,16427 +splrefinedpot,373,16427 +splashharmingleveliipotion,373,16428 +splashdamageleveliipotion,373,16428 +splashdmgleveliipotion,373,16428 +splashharminglevel2potion,373,16428 +splashdamagelevel2potion,373,16428 +splashdmglevel2potion,373,16428 +splashharmingiipotion,373,16428 +splashdamageiipotion,373,16428 +splashdmgiipotion,373,16428 +splashharmingleveliipot,373,16428 +splashdamageleveliipot,373,16428 +splashdmgleveliipot,373,16428 +splashharminglevel2pot,373,16428 +splashdamagelevel2pot,373,16428 +splashdmglevel2pot,373,16428 +splashharmingiipot,373,16428 +splashdamageiipot,373,16428 +splashdmgiipot,373,16428 +splharmingleveliipotion,373,16428 +spldamageleveliipotion,373,16428 +spldmgleveliipotion,373,16428 +splharminglevel2potion,373,16428 +spldamagelevel2potion,373,16428 +spldmglevel2potion,373,16428 +splharmingiipotion,373,16428 +spldamageiipotion,373,16428 +spldmgiipotion,373,16428 +splharmingleveliipot,373,16428 +spldamageleveliipot,373,16428 +spldmgleveliipot,373,16428 +splharminglevel2pot,373,16428 +spldamagelevel2pot,373,16428 +spldmglevel2pot,373,16428 +splharmingiipot,373,16428 +spldamageiipot,373,16428 +spldmgiipot,373,16428 +spd2pot,373,16428 +splashcordialpotion,373,16429 +splashcordialpot,373,16429 +splcordialpotion,373,16429 +splcordialpot,373,16429 +splashsparklingpotion,373,16430 +splashsparklingpot,373,16430 +splsparklingpotion,373,16430 +splsparklingpot,373,16430 +splashsparklingextendedpotion,373,16431 +splashsparklingexpotion,373,16431 +splashsparkling2potion,373,16431 +splashsparklingextendedpot,373,16431 +splashsparklingexpot,373,16431 +splashsparkling2pot,373,16431 +splsparklingextendedpotion,373,16431 +splsparklingexpotion,373,16431 +splsparkling2potion,373,16431 +splsparklingextendedpot,373,16431 +splsparklingexpot,373,16431 +splsparkling2pot,373,16431 +splashpotentpotion,373,16432 +splashpotentpot,373,16432 +splpotentpotion,373,16432 +splpotentpot,373,16432 +splashrankpotion,373,16438 +splashrankpot,373,16438 +splrankpotion,373,16438 +splrankpot,373,16438 +splashrankextendedpotion,373,16439 +splashrankexpotion,373,16439 +splashrank2potion,373,16439 +splashrankextendedpot,373,16439 +splashrankexpot,373,16439 +splashrank2pot,373,16439 +splrankextendedpotion,373,16439 +splrankexpotion,373,16439 +splrank2potion,373,16439 +splrankextendedpot,373,16439 +splrankexpot,373,16439 +splrank2pot,373,16439 +splashacridpotion,373,16443 +splashacridpot,373,16443 +splacridpotion,373,16443 +splacridpot,373,16443 +splashgrosspotion,373,16445 +splashgrosspot,373,16445 +splgrosspotion,373,16445 +splgrosspot,373,16445 +splashstinkypotion,373,16446 +splashstinkypot,373,16446 +splstinkypotion,373,16446 +splstinkypot,373,16446 +splashstinkyextendedpotion,373,16447 +splashstinkyexpotion,373,16447 +splashstinky2potion,373,16447 +splashstinkyextendedpot,373,16447 +splashstinkyexpot,373,16447 +splashstinky2pot,373,16447 +splstinkyextendedpotion,373,16447 +splstinkyexpotion,373,16447 +splstinky2potion,373,16447 +splstinkyextendedpot,373,16447 +splstinkyexpot,373,16447 +splstinky2pot,373,16447 +splashmundaneextendedpotion,373,16448 +splashmundaneexpotion,373,16448 +splashmundane2potion,373,16448 +splashmundaneextendedpot,373,16448 +splashmundaneexpot,373,16448 +splashmundane2pot,373,16448 +splmundaneextendedpotion,373,16448 +splmundaneexpotion,373,16448 +splmundane2potion,373,16448 +splmundaneextendedpot,373,16448 +splmundaneexpot,373,16448 +splmundane2pot,373,16448 +splashregenerationextendedpotion,373,16449 +splashregenerateextendedpotion,373,16449 +splashregenextendepotion,373,16449 +splashregenerationexpotion,373,16449 +splashregenerateexpotion,373,16449 +splashregenexpotion,373,16449 +splashregenerationextendedpot,373,16449 +splashregenerateextendedpot,373,16449 +splashregenextendepot,373,16449 +splashregenerationexpot,373,16449 +splashregenerateexpot,373,16449 +splashregenexpot,373,16449 +splregenerationextendedpotion,373,16449 +splregenerateextendedpotion,373,16449 +splregenextendepotion,373,16449 +splregenerationexpotion,373,16449 +splregenerateexpotion,373,16449 +splregenexpotion,373,16449 +splregenerationextendedpot,373,16449 +splregenerateextendedpot,373,16449 +splregenextendepot,373,16449 +splregenerationexpot,373,16449 +splregenerateexpot,373,16449 +splregenexpot,373,16449 +sprepot,373,16449 +splashswiftnessextendedpotion,373,16450 +splashswiftextendedpotion,373,16450 +splashspeedextendedpotion,373,16450 +splashswiftnessexpotion,373,16450 +splashswiftexpotion,373,16450 +splashspeedexpotion,373,16450 +splashswiftnessextendedpot,373,16450 +splashswiftextendedpot,373,16450 +splashspeedextendedpot,373,16450 +splashswiftnessexpot,373,16450 +splashswiftexpot,373,16450 +splashspeedexpot,373,16450 +splswiftnessextendedpotion,373,16450 +splswiftextendedpotion,373,16450 +splspeedextendedpotion,373,16450 +splswiftnessexpotion,373,16450 +splswiftexpotion,373,16450 +splspeedexpotion,373,16450 +splswiftnessextendedpot,373,16450 +splswiftextendedpot,373,16450 +splspeedextendedpot,373,16450 +splswiftnessexpot,373,16450 +splswiftexpot,373,16450 +splspeedexpot,373,16450 +spswepot,373,16450 +splashfireresistanceextendedpotion,373,16451 +splashfireresistextendedpotion,373,16451 +splashfireresextendedpotion,373,16451 +splashfireresistanceexpotion,373,16451 +splashfireresistexpotion,373,16451 +splashfireresexpotion,373,16451 +splashfireresistanceextendedpot,373,16451 +splashfireresistextendedpot,373,16451 +splashfireresextendedpot,373,16451 +splashfireresistanceexpot,373,16451 +splashfireresistexpot,373,16451 +splashfireresexpot,373,16451 +splfireresistanceextendedpotion,373,16451 +splfireresistextendedpotion,373,16451 +splfireresextendedpotion,373,16451 +splfireresistanceexpotion,373,16451 +splfireresistexpotion,373,16451 +splfireresexpotion,373,16451 +splfireresistanceextendedpot,373,16451 +splfireresistextendedpot,373,16451 +splfireresextendedpot,373,16451 +splfireresistanceexpot,373,16451 +splfireresistexpot,373,16451 +splfireresexpot,373,16451 +spfepot,373,16451 +splashpoisonextendedpotion,373,16452 +splashacidextendedpotion,373,16452 +splashpoisonexpotion,373,16452 +splashacidexpotion,373,16452 +splashpoisonextendedpot,373,16452 +splashacidextendedpot,373,16452 +splashpoisonexpot,373,16452 +splashacidexpot,373,16452 +splpoisonextendedpotion,373,16452 +splacidextendedpotion,373,16452 +splpoisonexpotion,373,16452 +splacidexpotion,373,16452 +splpoisonextendedpot,373,16452 +splacidextendedpot,373,16452 +splpoisonexpot,373,16452 +splacidexpot,373,16452 +sppepot,373,16452 +splashnightvisionextendedpotion,373,16454 +splashnvisionextendedpotion,373,16454 +splashnightvextendedpotion,373,16454 +splashdarkvisionextendedpotion,373,16454 +splashdvisionextendedpotion,373,16454 +splashdarkvextendedpotion,373,16454 +splashnightvisionextendedpot,373,16454 +splashnvisionextendedpot,373,16454 +splashnightvextendedpot,373,16454 +splashdarkvisionextendedpot,373,16454 +splashdvisionextendedpot,373,16454 +splashdarkvextendedpot,373,16454 +splashnightvisionexpotion,373,16454 +splashnvisionexpotion,373,16454 +splashnightvexpotion,373,16454 +splashdarkvisionexpotion,373,16454 +splashdvisionexpotion,373,16454 +splashdarkvexpotion,373,16454 +splashnightvisionexpot,373,16454 +splashnvisionexpot,373,16454 +splashnightvexpot,373,16454 +splashdarkvisionexpot,373,16454 +splashdvisionexpot,373,16454 +splashdarkvexpot,373,16454 +splnightvisionextendedpotion,373,16454 +splnvisionextendedpotion,373,16454 +splnightvextendedpotion,373,16454 +spldarkvisionextendedpotion,373,16454 +spldvisionextendedpotion,373,16454 +spldarkvextendedpotion,373,16454 +splnightvisionextendedpot,373,16454 +splnvisionextendedpot,373,16454 +splnightvextendedpot,373,16454 +spldarkvisionextendedpot,373,16454 +spldvisionextendedpot,373,16454 +spldarkvextendedpot,373,16454 +splnightvisionexpotion,373,16454 +splnvisionexpotion,373,16454 +splnightvexpotion,373,16454 +spldarkvisionexpotion,373,16454 +spldvisionexpotion,373,16454 +spldarkvexpotion,373,16454 +splnightvisionexpot,373,16454 +splnvisionexpot,373,16454 +splnightvexpot,373,16454 +spldarkvisionexpot,373,16454 +spldvisionexpot,373,16454 +spldarkvexpot,373,16454 +spnepot,373,16454 +splashweaknessextendedpotion,373,16456 +splashweakextendedpotion,373,16456 +splashweaknessexpotion,373,16456 +splashweakexpotion,373,16456 +splashweaknessextendedpot,373,16456 +splashweakextendedpot,373,16456 +splashweaknessexpot,373,16456 +splashweakexpot,373,16456 +splweaknessextendedpotion,373,16456 +sphweakextendedpotion,373,16456 +splweaknessexpotion,373,16456 +splweakexpotion,373,16456 +splweaknessextendedpot,373,16456 +splweakextendedpot,373,16456 +splweaknessexpot,373,16456 +splweakexpot,373,16456 +spwepot,373,16456 +splashstrengthextendedpotion,373,16457 +splashstrongextendedpotion,373,16457 +splashstrextendedpotion,373,16457 +splashstrengthexpotion,373,16457 +splashstrongexpotion,373,16457 +splashstrexpotion,373,16457 +splashstrengthextendedpot,373,16457 +splashstrongextendedpot,373,16457 +splashstrextendedpot,373,16457 +splashstrengthexpot,373,16457 +splashstrongexpot,373,16457 +splashstrexpot,373,16457 +splstrengthextendedpotion,373,16457 +splstrongextendedpotion,373,16457 +splstrextendedpotion,373,16457 +splstrengthexpotion,373,16457 +splstrongexpotion,373,16457 +splstrexpotion,373,16457 +splstrengthextendedpot,373,16457 +splstrongextendedpot,373,16457 +splstrextendedpot,373,16457 +splstrengthexpot,373,16457 +splstrongexpot,373,16457 +splstrexpot,373,16457 +spstepot,373,16457 +splashslownessextendedpotion,373,16458 +splashslowextenedpotion,373,16458 +splashslownessexpotion,373,16458 +splashslowexpotion,373,16458 +splashslownessextendedpot,373,16458 +splashslowextenedpot,373,16458 +splashslownessexpot,373,16458 +splashslowexpot,373,16458 +splslownessextendedpotion,373,16458 +splslowextenedpotion,373,16458 +splslownessexpotion,373,16458 +splslowexpotion,373,16458 +splslownessextendedpot,373,16458 +splslowextenedpot,373,16458 +splslownessexpot,373,16458 +splslowexpot,373,16458 +spslepot,373,16458 +splashleapingpotion,373,16459 +splashleappotion,373,16459 +splleapingpotion,373,16459 +splleappotion,373,16459 +leapingsplashpotion,373,16459 +leapsplashpotion,373,16459 +leapingsplpotion,373,16459 +leapsplpotion,373,16459 +splashwaterbreathingextendedpotion,373,16461 +splashwaterbreathextendedpotion,373,16461 +splashbreathingextendedpotion,373,16461 +splashbreathextendedpotion,373,16461 +splashwaterbreathingextendedpot,373,16461 +splashwaterbreathextendedpot,373,16461 +splashbreathingextendedpot,373,16461 +splashbreathextendedpot,373,16461 +splwaterbreathingextendedpotion,373,16461 +splwaterbreathextendedpotion,373,16461 +splbreathingextendedpotion,373,16461 +splbreathextendedpotion,373,16461 +splwaterbreathingextendedpot,373,16461 +splwaterbreathextendedpot,373,16461 +splbreathingextendedpot,373,16461 +splbreathextendedpot,373,16461 +splashwaterbreathingexpotion,373,16461 +splashwaterbreathexpotion,373,16461 +splashbreathingexpotion,373,16461 +splashbreathexpotion,373,16461 +splashwaterbreathingexpot,373,16461 +splashwaterbreathexpot,373,16461 +splashbreathingexpot,373,16461 +splashbreathexpot,373,16461 +splwaterbreathingexpotion,373,16461 +splwaterbreathexpotion,373,16461 +splbreathingexpotion,373,16461 +splbreathexpotion,373,16461 +splwaterbreathingexpot,373,16461 +splwaterbreathexpot,373,16461 +splbreathingexpot,373,16461 +splbreathexpot,373,16461 +spwbepot,373,16461 +splashinvisibilityextendedpotion,373,16462 +splashinvisibleextendedpotion,373,16462 +splashinvextendedpotion,373,16462 +splashinvisibilityextendedpot,373,16462 +splashinvisibleextendedpot,373,16462 +splashinvextendedpot,373,16462 +splashinvisibilityexpotion,373,16462 +splashinvisibleexpotion,373,16462 +splashinvexpotion,373,16462 +splashinvisibilityexpot,373,16462 +splashinvisibleexpot,373,16462 +splashinvexpot,373,16462 +splinvisibilityextendedpotion,373,16462 +splinvisibleextendedpotion,373,16462 +splinvextendedpotion,373,16462 +splinvisibilityextendedpot,373,16462 +splinvisibleextendedpot,373,16462 +splinvextendedpot,373,16462 +splinvisibilityexpotion,373,16462 +splinvisibleexpotion,373,16462 +splinvexpotion,373,16462 +splinvisibilityexpot,373,16462 +splinvisibleexpot,373,16462 +splinvexpot,373,16462 +spiepot,373,16462 +splashregenerationdualbitpotion,373,16481 +splashregeneratedualbitpotion,373,16481 +splashregendualbitpotion,373,16481 +splashregenerationdualbitpot,373,16481 +splashregeneratedualbitpot,373,16481 +splashregendualbitpot,373,16481 +splregenerationdualbitpotion,373,16481 +splregeneratedualbitpotion,373,16481 +splregendualbitpotion,373,16481 +splregenerationdualbitpot,373,16481 +splregeneratedualbitpot,373,16481 +splregendualbitpot,373,16481 +splashregenerationdbpotion,373,16481 +splashregeneratedbpotion,373,16481 +splashregendbpotion,373,16481 +splashregenerationdbpot,373,16481 +splashregeneratedbpot,373,16481 +splashregendbpot,373,16481 +splregenerationdbpotion,373,16481 +splregeneratedbpotion,373,16481 +splregendbpotion,373,16481 +splregenerationdbpot,373,16481 +splregeneratedbpot,373,16481 +splregendbpot,373,16481 +sprdbpot,373,16481 +splashswiftnessdualbitpotion,373,16482 +splashswiftdualbitpotion,373,16482 +splashspeeddualbitpotion,373,16482 +splashswiftnessdualbitpot,373,16482 +splashswiftdualbitpot,373,16482 +splashspeeddualbitpot,373,16482 +splswiftnessdualbitpotion,373,16482 +splswiftdualbitpotion,373,16482 +splspeeddualbitpotion,373,16482 +splswiftnessdualbitpot,373,16482 +splswiftdualbitpot,373,16482 +splspeeddualbitpot,373,16482 +splashswiftnessdbpotion,373,16482 +splashswiftdbpotion,373,16482 +splashspeeddbpotion,373,16482 +splashswiftnessdbpot,373,16482 +splashswiftdbpot,373,16482 +splashspeeddbpot,373,16482 +splswiftnessdbpotion,373,16482 +splswiftdbpotion,373,16482 +splspeeddbpotion,373,16482 +splswiftnessdbpot,373,16482 +splswiftdbpot,373,16482 +splspeeddbpot,373,16482 +spswdbpot,373,16482 +splashpoisondualbitpotion,373,16484 +splashaciddualbitpotion,373,16484 +splashpoisondualbitpot,373,16484 +splashaciddualbitpot,373,16484 +splpoisondualbitpotion,373,16484 +splaciddualbitpotion,373,16484 +splpoisondualbitpot,373,16484 +splaciddualbitpot,373,16484 +splashpoisondbpotion,373,16484 +splashaciddbpotion,373,16484 +splashpoisondbpot,373,16484 +splashaciddbpot,373,16484 +splpoisondbpotion,373,16484 +splaciddbpotion,373,16484 +splpoisondbpot,373,16484 +splaciddbpot,373,16484 +sppdbpot,373,16484 +splashstrengthdualbitpotion,373,16489 +splashstrongdualbitpotion,373,16489 +splashstrdualbitpotion,373,16489 +splashstrengthdualbitpot,373,16489 +splashstrongdualbitpot,373,16489 +splashstrdualbitpot,373,16489 +splstrengthdualbitpotion,373,16489 +splstrongdualbitpotion,373,16489 +splstrdualbitpotion,373,16489 +splstrengthdualbitpot,373,16489 +splstrongdualbitpot,373,16489 +splstrdualbitpot,373,16489 +splashstrengthdbpotion,373,16489 +splashstrongdbpotion,373,16489 +splashstrdbpotion,373,16489 +splashstrengthdbpot,373,16489 +splashstrongdbpot,373,16489 +splashstrdbpot,373,16489 +splstrengthdbpotion,373,16489 +splstrongdbpotion,373,16489 +splstrdbpotion,373,16489 +splstrengthdbpot,373,16489 +splstrongdbpot,373,16489 +splstrdbpot,373,16489 +spstdbpot,373,16489 +potionofluck,373,0 +potofluck,373,0 +luckpotion,373,0 +luckypotion,373,0 +glassbottle,374,0 +bottle,374,0 +gbottle,374,0 +gvase,374,0 +vase,374,0 +glassvase,374,0 +emptyglassbottle,374,0 +emptybottle,374,0 +emptygbottle,374,0 +emptygvase,374,0 +emptyvase,374,0 +emptyglassvase,374,0 +eglassbottle,374,0 +ebottle,374,0 +egbottle,374,0 +egvase,374,0 +evase,374,0 +eglassvase,374,0 +spidereye,375,0 +eyeofspider,375,0 +seye,375,0 +fermentedspidereye,376,0 +craftedspidereye,376,0 +fspidereye,376,0 +cspidereye,376,0 +fermentedeyeofspider,376,0 +craftedeyeofspider,376,0 +feyeofspider,376,0 +ceyeofspider,376,0 +fermentedseye,376,0 +craftedseye,376,0 +fseye,376,0 +cseye,376,0 +blazepowder,377,0 +blazedust,377,0 +goldpowder,377,0 +golddust,377,0 +gdust,377,0 +gpowder,377,0 +bpowder,377,0 +bdust,377,0 +magmacream,378,0 +goldcream,378,0 +blazecream,378,0 +mcream,378,0 +gcream,378,0 +bcream,378,0 +combinedcream,378,0 +ccream,378,0 +bstand,379,0 +pstand,379,0 +brewingstand,379,0 +potionstand,379,0 +cauld,380,0 +cauldron,380,0 +steelcauldron,380,0 +ironcauldron,380,0 +icauldron,380,0 +scauldron,380,0 +potioncauldron,380,0 +pcauldron,380,0 +eyeofender,381,0 +endereye,381,0 +endeye,381,0 +evilendereye,381,0 +evileyeofender,381,0 +evilenderpearl,381,0 +eeye,381,0 +eofender,381,0 +glisteringmelon,382,0 +speckledmelon,382,0 +goldmelon,382,0 +sparklymelon,382,0 +shiningmelon,382,0 +gmelon,382,0 +smelon,382,0 +creeperegg,383,50 +eggcreeper,383,50 +skeletonegg,383,51 +eggskeleton,383,51 +spideregg,383,52 +eggspider,383,52 +giantegg,383,53 +egggiant,383,53 +zombieegg,383,54 +eggzombie,383,54 +slimeegg,383,55 +eggslime,383,55 +ghastegg,383,56 +eggghast,383,56 +zombiepigmanegg,383,57 +zpigmanegg,383,57 +pigmanegg,383,57 +zombiepmanegg,383,57 +zpmanegg,383,57 +zombiepigmegg,383,57 +zpigmegg,383,57 +zombiepigegg,383,57 +zpigegg,383,57 +zombiepmegg,383,57 +zombiepegg,383,57 +eggzombiepigman,383,57 +eggzpigman,383,57 +eggpigman,383,57 +eggzombiepman,383,57 +eggzpman,383,57 +eggzombiepigm,383,57 +eggzpigm,383,57 +eggzombiepig,383,57 +eggzpig,383,57 +eggzombiepm,383,57 +eggzombiep,383,57 +endermanegg,383,58 +eggenderman,383,58 +eggcavespider,383,59 +cavespideregg,383,59 +silverfishegg,383,60 +eggsilverfish,383,60 +blazeegg,383,61 +eggblaze,383,61 +lavaslimeegg,383,62 +lavacubeegg,383,62 +magmacubeegg,383,62 +magmaslimeegg,383,62 +egglavaslime,383,62 +egglavacube,383,62 +eggmagmacube,383,62 +eggmagmaslime,383,62 +bategg,383,65 +eggbat,383,65 +witchegg,383,66 +eggwitch,383,66 +endermiteegg,383,67 +endermitespawnegg,383,67 +eggendermite,383,67 +guardianegg,383,68 +guardianspawnegg,383,68 +eggguardian,383,68 +spawneggshulker,383,69 +spawnshulker,383,69 +shulkerspawnegg,383,69 +shulkeregg,383,69 +shulkegg,383,69 +pigegg,383,90 +eggpig,383,90 +sheepegg,383,91 +eggsheep,383,91 +cowegg,383,92 +eggcow,383,92 +chickenegg,383,93 +eggchicken,383,93 +squidegg,383,94 +eggsquid,383,94 +wolfegg,383,95 +eggwolf,383,95 +mooshroomegg,383,96 +mushroomcowegg,383,96 +eggmooshroom,383,96 +eggmushroomcow,383,96 +snowgolemegg,383,97 +sgolemegg,383,97 +eggsnowgolem,383,97 +eggsgolem,383,97 +ocelotegg,383,98 +eggocelot,383,98 +irongolemegg,383,99 +igolemegg,383,99 +eggirongolem,383,99 +eggigolem,383,99 +egghorse,383,100 +horseegg,383,100 +rabbitegg,383,101 +rabbitspawnegg,383,101 +spawneggpolarbear,383,102 +spawneggpolar,383,102 +spawneggbear,383,102 +spawnpolarbear,383,102 +spawnpolar,383,102 +spawnbear,383,102 +polarbearspawnegg,383,102 +polarspawnegg,383,102 +bearspawnegg,383,102 +polarbearegg,383,102 +polaregg,383,102 +bearegg,383,102 +parrot,383,105 +villageregg,383,120 +eggvillager,383,120 +bottleofenchanting,384,0 +enchantingbottle,384,0 +expbottle,384,0 +xpbottle,384,0 +bottleexp,384,0 +bottlexp,384,0 +enchantbottle,384,0 +bottleenchanting,384,0 +bottleenchant,384,0 +bottleoenchanting,384,0 +firecharge,385,0 +fireball,385,0 +grenade,385,0 +bookandquill,386,0 +booknquill,386,0 +bookandfeather,386,0 +booknfeather,386,0 +writeablebook,386,0 +writtenbook,387,0 +readablebook,387,0 +sealedbook,387,0 +diary,387,0 +ownedbook,387,0 +emerald,388,0 +itemframe,389,0 +pictureframe,389,0 +iframe,389,0 +pframe,389,0 +flowerpot,390,0 +pot,390,0 +carrot,391,0 +potato,392,0 +rawpotato,392,0 +bakedpotato,393,0 +roastedpotato,393,0 +cookedpotato,393,0 +bakepotato,393,0 +roastpotato,393,0 +cookpotato,393,0 +bpotato,393,0 +rpotato,393,0 +cpotato,393,0 +poisonouspotato,394,0 +poisonpotato,394,0 +ppotato,394,0 +emptymap,395,0 +map,395,0 +goldencarrot,396,0 +goldcarrot,396,0 +gcarrot,396,0 +head,397,0 +skull,397,0 +skhead,397,0 +skeletonhead,397,0 +headskeleton,397,0 +skeletonskull,397,0 +skullskeleton,397,0 +witherhead,397,1 +witherskeletonhead,397,1 +wskeletionhead,397,1 +headwither,397,1 +headwitherskeleton,397,1 +headwskeletion,397,1 +witherskull,397,1 +witherskeletonskull,397,1 +wskeletionskull,397,1 +skullwither,397,1 +skullwitherskeleton,397,1 +skullwskeletion,397,1 +zohead,397,2 +zombiehead,397,2 +headzombie,397,2 +zombieskull,397,2 +skullzombie,397,2 +playerhead,397,3 +humanhead,397,3 +stevehead,397,3 +headplayer,397,3 +headhuman,397,3 +headsteve,397,3 +playerskull,397,3 +humanskull,397,3 +steveskull,397,3 +skullplayer,397,3 +skullhuman,397,3 +skullsteve,397,3 +crhead,397,4 +creeperhead,397,4 +headcreeper,397,4 +creeperskull,397,4 +skullcreeper,397,4 +dragonhead,397,5 +dragonmask,397,5 +dragonheadmask,397,5 +dragmask,397,5 +dragonskull,397,5 +dragskull,397,5 +carrotonastick,398,0 +carrotonstick,398,0 +netherstar,399,0 +hellstar,399,0 +nstar,399,0 +hstar,399,0 +star,399,0 +pumpkinpie,400,0 +pumpkincake,400,0 +ppie,400,0 +pcake,400,0 +pie,400,0 +fireworkrocket,401,0 +fireworkmissle,401,0 +firework,401,0 +fworkrocket,401,0 +fworkmissle,401,0 +fwork,401,0 +fwrocket,401,0 +fwmissle,401,0 +fireworkstar,402,0 +fworkstar,402,0 +fwstar,402,0 +fireworkball,402,0 +fworkball,402,0 +fwball,402,0 +fireworkpowder,402,0 +fworkpowder,402,0 +fwpowder,402,0 +fireworkcharge,402,0 +fworkcharge,402,0 +fwcharge,402,0 +enchantedbook,403,0 +enchantmentbook,403,0 +enchantingbook,403,0 +enchantbook,403,0 +magicalbook,403,0 +magicbook,403,0 +ebook,403,0 +mbook,403,0 +redstonecomparator,404,0 +redstonecomparer,404,0 +redstonecompare,404,0 +rstonecomparator,404,0 +rstonecomparer,404,0 +rstonecompare,404,0 +redscomparator,404,0 +redscomparer,404,0 +redscompare,404,0 +rscomparator,404,0 +rscomparer,404,0 +rscompare,404,0 +comparator,404,0 +comparer,404,0 +compare,404,0 +netherbrick,405,0 +nbrick,405,0 +hellbrick,405,0 +deathbrick,405,0 +dbrick,405,0 +hbrick,405,0 +netherquartz,406,0 +deathquartz,406,0 +hellquartz,406,0 +nquartz,406,0 +dquartz,406,0 +hquartz,406,0 +quartz,406,0 +tntminecart,407,0 +dynamiteminecart,407,0 +dynamitemcart,407,0 +dynamitecart,407,0 +bombminecart,407,0 +bombmcart,407,0 +bombcart,407,0 +tntmcart,407,0 +tntcart,407,0 +dminecart,407,0 +dmcart,407,0 +dcart,407,0 +bminecart,407,0 +bmcart,407,0 +bcart,407,0 +tminecart,407,0 +tmcart,407,0 +tcart,407,0 +hopperminecart,408,0 +hoppermcart,408,0 +hoppercart,408,0 +hopminecart,408,0 +hopmcart,408,0 +hopcart,408,0 +hminecart,408,0 +hmcart,408,0 +hcart,408,0 +prismarineshard,409,0 +priseshard,409,0 +prisemarinecrystals,410,0 +prisecrystals,410,0 +rabbit,411,0 +rabbitmeat,411,0 +cookedrabbit,412,0 +rabbitstew,413,0 +hasenpfeffer,413,0 +rabbitfoot,414,0 +rabbithide,415,0 +armorstand,416,0 +ironhorsearmor,417,0 +ironharmor,417,0 +ironarmor,417,0 +ihorsearmor,417,0 +iharmor,417,0 +iarmor,417,0 +steelhorsearmor,417,0 +steelharmor,417,0 +steelarmor,417,0 +shorsearmor,417,0 +sharmor,417,0 +sarmor,417,0 +goldenhorsearmor,418,0 +goldenharmor,418,0 +goldenarmor,418,0 +goldhorsearmor,418,0 +goldharmor,418,0 +goldarmor,418,0 +ghorsearmor,418,0 +gharmor,418,0 +garmor,418,0 +diamondhorsearmor,419,0 +diamondharmor,419,0 +diamondarmor,419,0 +dhorsearmor,419,0 +dharmor,419,0 +darmor,419,0 +crystalhorsearmor,419,0 +crystalharmor,419,0 +crystalarmor,419,0 +chorsearmor,419,0 +charmor,419,0 +carmor,419,0 +lead,420,0 +leash,420,0 +rope,420,0 +nametag,421,0 +tag,421,0 +commandblockminecart,422,0 +cmdblockminecart,422,0 +cblockminecart,422,0 +commandminecart,422,0 +cmdminecart,422,0 +cbminecart,422,0 +commandblockcart,422,0 +cmdblockcart,422,0 +cblockcart,422,0 +commandcart,422,0 +cmdcart,422,0 +cbcart,422,0 +mutton,423,0 +sheepmeat,423,0 +cookedmutton,424,0 +cookedsheep,424,0 +banner,425,0 +blackbanner,425,0 +standingbanner,425,0 +wallbanner,425,0 +redbanner,425,1 +greenbanner,425,2 +brownbanner,425,3 +bluebanner,425,4 +purplebanner,425,5 +cyanbanner,425,6 +lgreybanner,425,7 +lightgreybanner,425,7 +greybanner,425,8 +pinkbanner,425,9 +limebanner,425,10 +yellowbanner,425,11 +lbluebanner,425,12 +lightbluebanner,425,12 +magentabanner,425,13 +orangebanner,425,14 +whitebanner,425,15 +endcrystal,426,0 +endercrystal,426,0 +ecrystal,426,0 +dragoncrystal,426,0 +endgem,426,0 +endergem,426,0 +egem,426,0 +dragongem,426,0 +dragongem,426,0 +sprucedooritem,427,0 +birchdooritem,428,0 +jungledooritem,429,0 +acaciadooritem,430,0 +darkoakdooritem,431,0 +chorusfruit,432,0 +chorfruit,432,0 +corusfruit,432,0 +corfruit,432,0 +endfruit,432,0 +enderfruit,432,0 +purpurfruit,432,0 +purfruit,432,0 +purplefruit,432,0 +chorusfruitpopped,433,0 +corusfruitpopped,433,0 +fruitpopped,433,0 +poppedfruit,433,0 +poppedcfruit,433,0 +poppedendfruit,433,0 +poppedenderfruit,433,0 +poppedpurpurfruit,433,0 +poppedpurfruit,433,0 +chorpopped,433,0 +corpopped,433,0 +chorfruitpopped,433,0 +corfruitpopped,433,0 +beetroot,434,0 +broot,434,0 +beet,434,0 +beets,434,0 +beetplant,434,0 +beetcrop,434,0 +beetrootseed,435,0 +beetrootseeds,435,0 +brootseed,435,0 +brootseeds,435,0 +beetseed,435,0 +beetseeds,435,0 +beetsseeds,435,0 +beetplantseeds,435,0 +beetcropseeds,435,0 +beetrootsoup,436,0 +brootsoup,436,0 +beetsoup,436,0 +beetssoup,436,0 +beetplantsoup,436,0 +beetcropsoup,436,0 +redsoup,436,0 +dragonbreath,437,0 +dragonsbreath,437,0 +dbreath,437,0 +edragonbreath,437,0 +edragonsbreath,437,0 +dragonpotion,437,0 +dragonfire,437,0 +endbreath,437,0 +dragonpot,437,0 +watersplashpotion,438,0 +watersplashpot,438,0 +watersplash,438,0 +thrownwater,438,0 +thrownwaterpot,438,0 +splashwater,438,0 +splashpotionofluck,438,0 +splashpotofluck,438,0 +splashluckpotion,438,0 +lucksplashpotion,438,0 +luckysplashpotion,438,0 +luckysplashpot,438,0 +splashluckpot,438,0 +spectralarrow,439,0 +specterarrow,439,0 +glowstonearrow,439,0 +glowingarrow,439,0 +glowarrow,439,0 +arrowregeneration,440,0,{"Potion":"regeneration"} +regenerationarrow,440,0,*arrowregeneration +arrowregen,440,0,*arrowregeneration +regenarrow,440,0,*arrowregeneration +arrowswiftness,440,0,{"Potion":"swiftness"} +swiftnessarrow,440,0,*arrowswiftness +arrowswift,440,0,*arrowswiftness +swiftarrow,440,0,*arrowswiftness +arrowfireresist,440,0,{"Potion":"fire_resistance"} +fireresistarrow,440,0,*arrowfireresist +arrowfireres,440,0,*arrowfireresist +fireresarrow,440,0,*arrowfireresist +arrowhealing,440,0,{"Potion":"healing"} +healingarrow,440,0,*arrowhealing +arrowheal,440,0,*arrowhealing +healarrow,440,0,*arrowhealing +arrownightvision,440,0,{"Potion":"night_vision"} +nightvisionarrow,440,0,*arrownightvision +arrownv,440,0,*arrownightvision +nvarrow,440,0,*arrownightvision +arrowstrength,440,0,{"Potion":"strength"} +strengtharrow,440,0,*arrowstrength +arrowstr,440,0,*arrowstrength +strarrow,440,0,*arrowstrength +arrowleaping,440,0,{"Potion":"leaping"} +leapingarrow,440,0,*arrowleaping +arrowleap,440,0,*arrowleaping +leaparrow,440,0,*arrowleaping +arrowinvisibility,440,0,{"Potion":"invisibility"} +invisibilityarrow,440,0,*arrowinvisibility +arrowinvis,440,0,*arrowinvisibility +invisarrow,440,0,*arrowinvisibility +arrowpoison,440,0,{"Potion":"poison"} +poisonarrow,440,0,*arrowpoison +arrowpoi,440,0,*arrowpoison +poiarrow,440,0,*arrowpoison +arrowweakness,440,0,{"Potion":"weakness"} +weaknessarrow,440,0,*arrowweakness +arrowweak,440,0,*arrowweakness +weakarrow,440,0,*arrowweakness +arrowslowness,440,0,{"Potion":"slowness"} +slownessarrow,440,0,*arrowslowness +arrowslow,440,0,*arrowslowness +slowarrow,440,0,*arrowslowness +arrowharming,440,0,{"Potion":"harming"} +harmingarrow,440,0,*arrowharming +arrowharm,440,0,*arrowharming +harmarrow,440,0,*arrowharming +arrowwaterbreathing,440,0,{"Potion":"water_breathing"} +waterbreathingarrow,440,0,*arrowwaterbreathing +arrowwb,440,0,*arrowwaterbreathing +wbarrow,440,0,*arrowwaterbreathing +arrowluck,440,0,{"Potion":"luck"} +luckarrow,440,0,*arrowluck +arrowlucky,440,0,*arrowluck +luckyarrow,440,0,*arrowluck +arrowregeneration2,440,0,{"Potion":"long_regeneration"} +regenerationarrow2,440,0,*arrowregeneration2 +arrowregen2,440,0,*arrowregeneration2 +regenarrow2,440,0,*arrowregeneration2 +arrowswiftness2,440,0,{"Potion":"long_swiftness"} +swiftnessarrow2,440,0,*arrowswiftness2 +arrowswift2,440,0,*arrowswiftness2 +swiftarrow2,440,0,*arrowswiftness2 +arrowfireresist2,440,0,{"Potion":"long_fire_resistance"} +fireresistarrow2,440,0,*arrowfireresist2 +arrowfireres2,440,0,*arrowfireresist2 +fireresarrow2,440,0,*arrowfireresist2 +arrownightvision2,440,0,{"Potion":"long_night_vision"} +nightvisionarrow2,440,0,*arrownightvision2 +arrownv2,440,0,*arrownightvision2 +nvarrow2,440,0,*arrownightvision2 +arrowstrength2,440,0,{"Potion":"long_strength"} +strengtharrow2,440,0,*arrowstrength2 +arrowstr,440,0,*arrowstrength2 +strarrow,440,0,*arrowstrength2 +arrowleaping2,440,0,{"Potion":"long_leaping"} +leapingarrow2,440,0,*arrowleaping2 +arrowleap2,440,0,*arrowleaping2 +leaparrow2,440,0,*arrowleaping2 +arrowinvisibility2,440,0,{"Potion":"long_invisibility"} +invisibilityarrow2,440,0,*arrowinvisibility2 +arrowinvis2,440,0,*arrowinvisibility2 +invisarrow2,440,0,*arrowinvisibility2 +arrowpoison2,440,0,{"Potion":"long_poison"} +poisonarrow2,440,0,*arrowpoison2 +arrowpoi2,440,0,*arrowpoison2 +poiarrow2,440,0,*arrowpoison2 +arrowweakness2,440,0,{"Potion":"long_weakness"} +weaknessarrow2,440,0,*arrowweakness2 +arrowweak2,440,0,*arrowweakness2 +weakarrow2,440,0,*arrowweakness2 +arrowslowness2,440,0,{"Potion":"long_slowness"} +slownessarrow2,440,0,*arrowslowness2 +arrowslow2,440,0,*arrowslowness2 +slowarrow2,440,0,*arrowslowness2 +arrowwaterbreathing2,440,0,{"Potion":"long_water_breathing"} +waterbreathingarrow2,440,0,*arrowwaterbreathing2 +arrowwb2,440,0,*arrowwaterbreathing2 +wbarrow2,440,0,*arrowwaterbreathing2 +arrowregenerationii,440,0,{"Potion":"strong_regeneration"} +regenerationarrowii,440,0,*arrowregenerationii +arrowregenii,440,0,*arrowregenerationii +regenarrowii,440,0,*arrowregenerationii +arrowswiftnessii,440,0,{"Potion":"strong_swiftness"} +swiftnessarrowii,440,0,*arrowswiftnessii +arrowswiftii,440,0,*arrowswiftnessii +swiftarrowii,440,0,*arrowswiftnessii +arrowhealingii,440,0,{"Potion":"strong_healing"} +healingarrowii,440,0,*arrowhealingii +arrowhealii,440,0,*arrowhealingii +healarrowii,440,0,*arrowhealingii +arrowstrengthii,440,0,{"Potion":"strong_strength"} +strengtharrowii,440,0,*arrowstrengthii +arrowstrii,440,0,*arrowstrengthii +strarrowii,440,0,*arrowstrengthii +arrowleapingii,440,0,{"Potion":"strong_leaping"} +leapingarrowii,440,0,*arrowleapingii +arrowleapii,440,0,*arrowleapingii +leaparrowii,440,0,*arrowleapingii +arrowpoisonii,440,0,{"Potion":"strong_poison"} +poisonarrowii,440,0,*arrowpoisonii +arrowpoiii,440,0,*arrowpoisonii +poiarrowii,440,0,*arrowpoisonii +arrowharmingii,440,0,{"Potion":"strong_harming"} +harmingarrowii,440,0,*arrowharmingii +arrowharmii,440,0,*arrowharmingii +harmarrowii,440,0,*arrowharmingii +lingeringpotion,441,0 +lingerpotion,441,0 +lingerpot,441,0 +aoepotion,441,0 +aoepot,441,0 +areapotion,441,0 +areapot,441,0 +cloudpotion,441,0 +cloudpot,441,0 +lingerpotregenerationii,441,0,{"Potion":"strong_regeneration"} +regenerationlingerpotii,441,0,*lingerpotregenerationii +lingerpotregenii,441,0,*lingerpotregenerationii +regenlingerpotii,441,0,*lingerpotregenerationii +lingerpotswiftnessii,441,0,{"Potion":"strong_swiftness"} +swiftnesslingerpotii,441,0,*lingerpotswiftnessii +lingerpotswiftii,441,0,*lingerpotswiftnessii +swiftlingerpotii,441,0,*lingerpotswiftnessii +lingerpothealingii,441,0,{"Potion":"strong_healing"} +healinglingerpotii,441,0,*lingerpothealingii +lingerpothealii,441,0,*lingerpothealingii +heallingerpotii,441,0,*lingerpothealingii +lingerpotstrengthii,441,0,{"Potion":"strong_strength"} +strengthlingerpotii,441,0,*lingerpotstrengthii +lingerpotstrii,441,0,*lingerpotstrengthii +strlingerpotii,441,0,*lingerpotstrengthii +lingerpotleapingii,441,0,{"Potion":"strong_leaping"} +leapinglingerpotii,441,0,*lingerpotleapingii +lingerpotleapii,441,0,*lingerpotleapingii +leaplingerpotii,441,0,*lingerpotleapingii +lingerpotpoisonii,441,0,{"Potion":"strong_poison"} +poisonlingerpotii,441,0,*lingerpotpoisonii +lingerpotpoiii,441,0,*lingerpotpoisonii +poilingerpotii,441,0,*lingerpotpoisonii +lingerpotharmingii,441,0,{"Potion":"strong_harming"} +harminglingerpotii,441,0,*lingerpotharmingii +lingerpotharmii,441,0,*lingerpotharmingii +harmlingerpotii,441,0,*lingerpotharmingii +lingerpotregeneration2,441,0,{"Potion":"long_regeneration"} +regenerationlingerpot2,441,0,*lingerpotregeneration2 +lingerpotregen2,441,0,*lingerpotregeneration2 +regenlingerpot2,441,0,*lingerpotregeneration2 +lingerpotswiftness2,441,0,{"Potion":"long_swiftness"} +swiftnesslingerpot2,441,0,*lingerpotswiftness2 +lingerpotswift2,441,0,*lingerpotswiftness2 +swiftlingerpot2,441,0,*lingerpotswiftness2 +lingerpotfireresist2,441,0,{"Potion":"long_fire_resistance"} +fireresistlingerpot2,441,0,*lingerpotfireresist2 +lingerpotfireres2,441,0,*lingerpotfireresist2 +firereslingerpot2,441,0,*lingerpotfireresist2 +lingerpotnightvision2,441,0,{"Potion":"long_night_vision"} +nightvisionlingerpot2,441,0,*lingerpotnightvision2 +lingerpotnv2,441,0,*lingerpotnightvision2 +nvlingerpot2,441,0,*lingerpotnightvision2 +lingerpotstrength2,441,0,{"Potion":"long_strength"} +strengthlingerpot2,441,0,*lingerpotstrength2 +lingerpotstr2,441,0,*lingerpotstrength2 +strlingerpot2,441,0,*lingerpotstrength2 +lingerpotleaping2,441,0,{"Potion":"long_leaping"} +leapinglingerpot2,441,0,*lingerpotleaping2 +lingerpotleap2,441,0,*lingerpotleaping2 +leaplingerpot2,441,0,*lingerpotleaping2 +lingerpotinvisibility2,441,0,{"Potion":"long_invisibility"} +invisibilitylingerpot2,441,0,*lingerpotinvisibility2 +lingerpotinvis2,441,0,*lingerpotinvisibility2 +invislingerpot2,441,0,*lingerpotinvisibility2 +lingerpotpoison2,441,0,{"Potion":"long_poison"} +poisonlingerpot2,441,0,*lingerpotpoison2 +lingerpotpo2i,441,0,*lingerpotpoison2 +poilingerpot2,441,0,*lingerpotpoison2 +lingerpotweakness2,441,0,{"Potion":"long_weakness"} +weaknesslingerpot2,441,0,*lingerpotweakness2 +lingerpotweak2,441,0,*lingerpotweakness2 +weaklingerpot2,441,0,*lingerpotweakness2 +lingerpotslowness2,441,0,{"Potion":"long_slowness"} +slownesslingerpot2,441,0,*lingerpotslowness2 +lingerpotslow2,441,0,*lingerpotslowness2 +slowlingerpot2,441,0,*lingerpotslowness2 +lingerpotwaterbreathing2,441,0,{"Potion":"long_water_breathing"} +waterbreathinglingerpot2,441,0,*lingerpotwaterbreathing2 +lingerpotwb2,441,0,*lingerpotwaterbreathing2 +wblingerpot2,441,0,*lingerpotwaterbreathing2 +lingerpotregeneration,441,0,{"Potion":"regeneration"} +regenerationlingerpot,441,0,*lingerpotregeneration +lingerpotregen,441,0,*lingerpotregeneration +regenlingerpot,441,0,*lingerpotregeneration +lingerpotswiftness,441,0,{"Potion":"swiftness"} +swiftnesslingerpot,441,0,*lingerpotswiftness +lingerpotswift,441,0,*lingerpotswiftness +swiftlingerpot,441,0,*lingerpotswiftness +lingerpotfireresist,441,0,{"Potion":"fire_resistance"} +fireresistlingerpot,441,0,*lingerpotfireresist +lingerpotfireres,441,0,*lingerpotfireresist +firereslingerpot,441,0,*lingerpotfireresist +lingerpothealing,441,0,{"Potion":"healing"} +healinglingerpot,441,0,*lingerpothealing +lingerpotheal,441,0,*lingerpothealing +heallingerpot,441,0,*lingerpothealing +lingerpotnightvision,441,0,{"Potion":"night_vision"} +nightvisionlingerpot,441,0,*lingerpotnightvision +lingerpotnv,441,0,*lingerpotnightvision +nvlingerpot,441,0,*lingerpotnightvision +lingerpotstrength,441,0,{"Potion":"strength"} +strengthlingerpot,441,0,*lingerpotstrength +lingerpotstr,441,0,*lingerpotstrength +strlingerpot,441,0,*lingerpotstrength +lingerpotleaping,441,0,{"Potion":"leaping"} +leapinglingerpot,441,0,*lingerpotleaping +lingerpotleap,441,0,*lingerpotleaping +leaplingerpot,441,0,*lingerpotleaping +lingerpotinvisibility,441,0,{"Potion":"invisibility"} +invisibilitylingerpot,441,0,*lingerpotinvisibility +lingerpotinvis,441,0,*lingerpotinvisibility +invislingerpot,441,0,*lingerpotinvisibility +lingerpotpoison,441,0,{"Potion":"poison"} +poisonlingerpot,441,0,*lingerpotpoison +lingerpotpoi,441,0,*lingerpotpoison +poilingerpot,441,0,*lingerpotpoison +lingerpotweakness,441,0,{"Potion":"weakness"} +weaknesslingerpot,441,0,*lingerpotweakness +lingerpotweak,441,0,*lingerpotweakness +weaklingerpot,441,0,*lingerpotweakness +lingerpotslowness,441,0,{"Potion":"slowness"} +slownesslingerpot,441,0,*lingerpotslowness +lingerpotslow,441,0,*lingerpotslowness +slowlingerpot,441,0,*lingerpotslowness +lingerpotharming,441,0,{"Potion":"harming"} +harminglingerpot,441,0,*lingerpotharming +lingerpotharm,441,0,*lingerpotharming +harmlingerpot,441,0,*lingerpotharming +lingerpotwaterbreathing,441,0,{"Potion":"water_breathing"} +waterbreathinglingerpot,441,0,*lingerpotwaterbreathing +lingerpotwb,441,0,*lingerpotwaterbreathing +wblingerpot,441,0,*lingerpotwaterbreathing +lingerpotluck,441,0,{"Potion":"luck"} +lucklingerpot,441,0,*lingerpotluck +lingerpotlucky,441,0,*lingerpotluck +luckylingerpot,441,0,*lingerpotluck +aoepotregenerationii,441,0,{"Potion":"strong_regeneration"} +regenerationaoepotii,441,0,*aoepotregenerationii +aoepotregenii,441,0,*aoepotregenerationii +regenaoepotii,441,0,*aoepotregenerationii +aoepotswiftnessii,441,0,{"Potion":"strong_swiftness"} +swiftnessaoepotii,441,0,*aoepotswiftnessii +aoepotswiftii,441,0,*aoepotswiftnessii +swiftaoepotii,441,0,*aoepotswiftnessii +aoepothealingii,441,0,{"Potion":"strong_healing"} +healingaoepotii,441,0,*aoepothealingii +aoepothealii,441,0,*aoepothealingii +healaoepotii,441,0,*aoepothealingii +aoepotstrengthii,441,0,{"Potion":"strong_strength"} +strengthaoepotii,441,0,*aoepotstrengthii +aoepotstrii,441,0,*aoepotstrengthii +straoepotii,441,0,*aoepotstrengthii +aoepotleapingii,441,0,{"Potion":"strong_leaping"} +leapingaoepotii,441,0,*aoepotleapingii +aoepotleapii,441,0,*aoepotleapingii +leapaoepotii,441,0,*aoepotleapingii +aoepotpoisonii,441,0,{"Potion":"strong_poison"} +poisonaoepotii,441,0,*aoepotpoisonii +aoepotpoiii,441,0,*aoepotpoisonii +poiaoepotii,441,0,*aoepotpoisonii +aoepotharmingii,441,0,{"Potion":"strong_harming"} +harmingaoepotii,441,0,*aoepotharmingii +aoepotharmii,441,0,*aoepotharmingii +harmaoepotii,441,0,*aoepotharmingii +aoepotregeneration2,441,0,{"Potion":"long_regeneration"} +regenerationaoepot2,441,0,*aoepotregeneration2 +aoepotregen2,441,0,*aoepotregeneration2 +regenaoepot2,441,0,*aoepotregeneration2 +aoepotswiftness2,441,0,{"Potion":"long_swiftness"} +swiftnessaoepot2,441,0,*aoepotswiftness2 +aoepotswift2,441,0,*aoepotswiftness2 +swiftaoepot2,441,0,*aoepotswiftness2 +aoepotfireresist2,441,0,{"Potion":"long_fire_resistance"} +fireresistaoepot2,441,0,*aoepotfireresist2 +aoepotfireres2,441,0,*aoepotfireresist2 +fireresaoepot2,441,0,*aoepotfireresist2 +aoepotnightvision2,441,0,{"Potion":"long_night_vision"} +nightvisionaoepot2,441,0,*aoepotnightvision2 +aoepotnv2,441,0,*aoepotnightvision2 +nvaoepot2,441,0,*aoepotnightvision2 +aoepotstrength2,441,0,{"Potion":"long_strength"} +strengthaoepot2,441,0,*aoepotstrength2 +aoepotstr2,441,0,*aoepotstrength2 +straoepot2,441,0,*aoepotstrength2 +aoepotleaping2,441,0,{"Potion":"long_leaping"} +leapingaoepot2,441,0,*aoepotleaping2 +aoepotleap2,441,0,*aoepotleaping2 +leapaoepot2,441,0,*aoepotleaping2 +aoepotinvisibility2,441,0,{"Potion":"long_invisibility"} +invisibilityaoepot2,441,0,*aoepotinvisibility2 +aoepotinvis2,441,0,*aoepotinvisibility2 +invisaoepot2,441,0,*aoepotinvisibility2 +aoepotpoison2,441,0,{"Potion":"long_poison"} +poisonaoepot2,441,0,*aoepotpoison2 +aoepotpo2i,441,0,*aoepotpoison2 +poiaoepot2,441,0,*aoepotpoison2 +aoepotweakness2,441,0,{"Potion":"long_weakness"} +weaknessaoepot2,441,0,*aoepotweakness2 +aoepotweak2,441,0,*aoepotweakness2 +weakaoepot2,441,0,*aoepotweakness2 +aoepotslowness2,441,0,{"Potion":"long_slowness"} +slownessaoepot2,441,0,*aoepotslowness2 +aoepotslow2,441,0,*aoepotslowness2 +slowaoepot2,441,0,*aoepotslowness2 +aoepotwaterbreathing2,441,0,{"Potion":"long_water_breathing"} +waterbreathingaoepot2,441,0,*aoepotwaterbreathing2 +aoepotwb2,441,0,*aoepotwaterbreathing2 +wbaoepot2,441,0,*aoepotwaterbreathing2 +aoepotregeneration,441,0,{"Potion":"regeneration"} +regenerationaoepot,441,0,*aoepotregeneration +aoepotregen,441,0,*aoepotregeneration +regenaoepot,441,0,*aoepotregeneration +aoepotswiftness,441,0,{"Potion":"swiftness"} +swiftnessaoepot,441,0,*aoepotswiftness +aoepotswift,441,0,*aoepotswiftness +swiftaoepot,441,0,*aoepotswiftness +aoepotfireresist,441,0,{"Potion":"fire_resistance"} +fireresistaoepot,441,0,*aoepotfireresist +aoepotfireres,441,0,*aoepotfireresist +fireresaoepot,441,0,*aoepotfireresist +aoepothealing,441,0,{"Potion":"healing"} +healingaoepot,441,0,*aoepothealing +aoepotheal,441,0,*aoepothealing +healaoepot,441,0,*aoepothealing +aoepotnightvision,441,0,{"Potion":"night_vision"} +nightvisionaoepot,441,0,*aoepotnightvision +aoepotnv,441,0,*aoepotnightvision +nvaoepot,441,0,*aoepotnightvision +aoepotstrength,441,0,{"Potion":"strength"} +strengthaoepot,441,0,*aoepotstrength +aoepotstr,441,0,*aoepotstrength +straoepot,441,0,*aoepotstrength +aoepotleaping,441,0,{"Potion":"leaping"} +leapingaoepot,441,0,*aoepotleaping +aoepotleap,441,0,*aoepotleaping +leapaoepot,441,0,*aoepotleaping +aoepotinvisibility,441,0,{"Potion":"invisibility"} +invisibilityaoepot,441,0,*aoepotinvisibility +aoepotinvis,441,0,*aoepotinvisibility +invisaoepot,441,0,*aoepotinvisibility +aoepotpoison,441,0,{"Potion":"poison"} +poisonaoepot,441,0,*aoepotpoison +aoepotpoi,441,0,*aoepotpoison +poiaoepot,441,0,*aoepotpoison +aoepotweakness,441,0,{"Potion":"weakness"} +weaknessaoepot,441,0,*aoepotweakness +aoepotweak,441,0,*aoepotweakness +weakaoepot,441,0,*aoepotweakness +aoepotslowness,441,0,{"Potion":"slowness"} +slownessaoepot,441,0,*aoepotslowness +aoepotslow,441,0,*aoepotslowness +slowaoepot,441,0,*aoepotslowness +aoepotharming,441,0,{"Potion":"harming"} +harmingaoepot,441,0,*aoepotharming +aoepotharm,441,0,*aoepotharming +harmaoepot,441,0,*aoepotharming +aoepotwaterbreathing,441,0,{"Potion":"water_breathing"} +waterbreathingaoepot,441,0,*aoepotwaterbreathing +aoepotwb,441,0,*aoepotwaterbreathing +wbaoepot,441,0,*aoepotwaterbreathing +aoepotluck,441,0,{"Potion":"luck"} +luckaoepot,441,0,*aoepotluck +aoepotlucky,441,0,*aoepotluck +luckyaoepot,441,0,*aoepotluck +shield,442,0 +handshield,442,0 +woodshield,442,0 +woodenshield,442,0 +elytra,443,0 +hangglider,443,0 +glider,443,0 +wings,443,0 +wing,443,0 +playerwings,443,0 +playerwing,443,0 +pwings,443,0 +pwing,443,0 +spruceboat,444,0 +birchboat,445,0 +jungleboat,446,0 +acaciaboat,447,0 +darkoakboat,448,0 +totemofundying,448,0 +totem,449,0 +shulkershell,450,0 +ironnugget,452,0 +knowledgebook,453,0 +13disc,2256,0 +goldmusicrecord,2256,0 +goldmusicdisk,2256,0 +goldmusicdisc,2256,0 +goldmusiccd,2256,0 +13musicrecord,2256,0 +13musicdisk,2256,0 +13musicdisc,2256,0 +13musiccd,2256,0 +gomusicrecord,2256,0 +gomusicdisk,2256,0 +gomusicdisc,2256,0 +gomusiccd,2256,0 +goldmrecord,2256,0 +goldmdisk,2256,0 +goldmdisc,2256,0 +goldmcd,2256,0 +13mrecord,2256,0 +13mdisk,2256,0 +13mdisc,2256,0 +13mcd,2256,0 +gomrecord,2256,0 +gomdisk,2256,0 +gomdisc,2256,0 +gomcd,2256,0 +goldrecord,2256,0 +golddisk,2256,0 +golddisc,2256,0 +goldcd,2256,0 +13record,2256,0 +13disk,2256,0 +13cd,2256,0 +gorecord,2256,0 +godisk,2256,0 +godisc,2256,0 +gocd,2256,0 +record1,2256,0 +disk1,2256,0 +disc1,2256,0 +cd1,2256,0 +1record,2256,0 +1disk,2256,0 +1disc,2256,0 +1cd,2256,0 +catdisc,2257,0 +greenmusicrecord,2257,0 +greenmusicdisk,2257,0 +greenmusicdisc,2257,0 +greenmusiccd,2257,0 +catmusicrecord,2257,0 +catmusicdisk,2257,0 +catmusicdisc,2257,0 +catmusiccd,2257,0 +grmusicrecord,2257,0 +grmusicdisk,2257,0 +grmusicdisc,2257,0 +grmusiccd,2257,0 +greenmrecord,2257,0 +greenmdisk,2257,0 +greenmdisc,2257,0 +greenmcd,2257,0 +catmrecord,2257,0 +catmdisk,2257,0 +catmdisc,2257,0 +catmcd,2257,0 +grmrecord,2257,0 +grmdisk,2257,0 +grmdisc,2257,0 +grmcd,2257,0 +greenrecord,2257,0 +greendisk,2257,0 +greendisc,2257,0 +greencd,2257,0 +catrecord,2257,0 +catdisk,2257,0 +catcd,2257,0 +grrecord,2257,0 +grdisk,2257,0 +grdisc,2257,0 +grcd,2257,0 +record2,2257,0 +disk2,2257,0 +disc2,2257,0 +cd2,2257,0 +2record,2257,0 +2disk,2257,0 +2disc,2257,0 +2cd,2257,0 +blocksdisc,2258,0 +orangemusicrecord,2258,0 +orangemusicdisk,2258,0 +orangemusicdisc,2258,0 +orangemusiccd,2258,0 +blocksmusicrecord,2258,0 +blocksmusicdisk,2258,0 +blocksmusicdisc,2258,0 +blocksmusiccd,2258,0 +ormusicrecord,2258,0 +ormusicdisk,2258,0 +ormusicdisc,2258,0 +ormusiccd,2258,0 +orangemrecord,2258,0 +orangemdisk,2258,0 +orangemdisc,2258,0 +orangemcd,2258,0 +blocksmrecord,2258,0 +blocksmdisk,2258,0 +blocksmdisc,2258,0 +blocksmcd,2258,0 +ormrecord,2258,0 +ormdisk,2258,0 +ormdisc,2258,0 +ormcd,2258,0 +orangerecord,2258,0 +orangedisk,2258,0 +orangedisc,2258,0 +orangecd,2258,0 +blocksrecord,2258,0 +blocksdisk,2258,0 +blockscd,2258,0 +orrecord,2258,0 +ordisk,2258,0 +ordisc,2258,0 +orcd,2258,0 +record3,2258,0 +disk3,2258,0 +disc3,2258,0 +cd3,2258,0 +3record,2258,0 +3disk,2258,0 +3disc,2258,0 +3cd,2258,0 +chirpdisc,2259,0 +redmusicrecord,2259,0 +redmusicdisk,2259,0 +redmusicdisc,2259,0 +redmusiccd,2259,0 +chirpmusicrecord,2259,0 +chirpmusicdisk,2259,0 +chirpmusicdisc,2259,0 +chirpmusiccd,2259,0 +remusicrecord,2259,0 +remusicdisk,2259,0 +remusicdisc,2259,0 +remusiccd,2259,0 +redmrecord,2259,0 +redmdisk,2259,0 +redmdisc,2259,0 +redmcd,2259,0 +chirpmrecord,2259,0 +chirpmdisk,2259,0 +chirpmdisc,2259,0 +chirpmcd,2259,0 +remrecord,2259,0 +remdisk,2259,0 +remdisc,2259,0 +remcd,2259,0 +redrecord,2259,0 +reddisk,2259,0 +reddisc,2259,0 +redcd,2259,0 +chirprecord,2259,0 +chirpdisk,2259,0 +chirpcd,2259,0 +rerecord,2259,0 +redisk,2259,0 +redisc,2259,0 +recd,2259,0 +record4,2259,0 +disk4,2259,0 +disc4,2259,0 +cd4,2259,0 +4record,2259,0 +4disk,2259,0 +4disc,2259,0 +4cd,2259,0 +fardisc,2260,0 +lightgreenmusicrecord,2260,0 +lightgreenmusicdisk,2260,0 +lightgreenmusicdisc,2260,0 +lightgreenmusiccd,2260,0 +lgreenmusicrecord,2260,0 +lgreenmusicdisk,2260,0 +lgreenmusicdisc,2260,0 +lgreenmusiccd,2260,0 +lightgrmusicrecord,2260,0 +lightgrmusicdisk,2260,0 +lightgrmusicdisc,2260,0 +lightgrmusiccd,2260,0 +farmusicrecord,2260,0 +farmusicdisk,2260,0 +farmusicdisc,2260,0 +farmusiccd,2260,0 +lgrmusicrecord,2260,0 +lgrmusicdisk,2260,0 +lgrmusicdisc,2260,0 +lgrmusiccd,2260,0 +lightgreenmrecord,2260,0 +lightgreenmdisk,2260,0 +lightgreenmdisc,2260,0 +lightgreenmcd,2260,0 +lgreenmrecord,2260,0 +lgreenmdisk,2260,0 +lgreenmdisc,2260,0 +lgreenmcd,2260,0 +lightgrmrecord,2260,0 +lightgrmdisk,2260,0 +lightgrmdisc,2260,0 +lightgrmcd,2260,0 +farmrecord,2260,0 +farmdisk,2260,0 +farmdisc,2260,0 +farmcd,2260,0 +lgrmrecord,2260,0 +lgrmdisk,2260,0 +lgrmdisc,2260,0 +lgrmcd,2260,0 +lightgreenrecord,2260,0 +lightgreendisk,2260,0 +lightgreendisc,2260,0 +lightgreencd,2260,0 +lgreenrecord,2260,0 +lgreendisk,2260,0 +lgreendisc,2260,0 +lgreencd,2260,0 +lightgrrecord,2260,0 +lightgrdisk,2260,0 +lightgrdisc,2260,0 +lightgrcd,2260,0 +farrecord,2260,0 +fardisk,2260,0 +farcd,2260,0 +lgrrecord,2260,0 +lgrdisk,2260,0 +lgrdisc,2260,0 +lgrcd,2260,0 +record5,2260,0 +disk5,2260,0 +disc5,2260,0 +cd5,2260,0 +5record,2260,0 +5disk,2260,0 +5disc,2260,0 +5cd,2260,0 +malldisc,2261,0 +purplemusicrecord,2261,0 +purplemusicdisk,2261,0 +purplemusicdisc,2261,0 +purplemusiccd,2261,0 +mallmusicrecord,2261,0 +mallmusicdisk,2261,0 +mallmusicdisc,2261,0 +mallmusiccd,2261,0 +pumusicrecord,2261,0 +pumusicdisk,2261,0 +pumusicdisc,2261,0 +pumusiccd,2261,0 +purplemrecord,2261,0 +purplemdisk,2261,0 +purplemdisc,2261,0 +purplemcd,2261,0 +mallmrecord,2261,0 +mallmdisk,2261,0 +mallmdisc,2261,0 +mallmcd,2261,0 +pumrecord,2261,0 +pumdisk,2261,0 +pumdisc,2261,0 +pumcd,2261,0 +purplerecord,2261,0 +purpledisk,2261,0 +purpledisc,2261,0 +purplecd,2261,0 +mallrecord,2261,0 +malldisk,2261,0 +mallcd,2261,0 +purecord,2261,0 +pudisk,2261,0 +pudisc,2261,0 +pucd,2261,0 +record6,2261,0 +disk6,2261,0 +disc6,2261,0 +cd6,2261,0 +6record,2261,0 +6disk,2261,0 +6disc,2261,0 +6cd,2261,0 +mellohidisc,2262,0 +pinkmusicrecord,2262,0 +pinkmusicdisk,2262,0 +pinkmusicdisc,2262,0 +pinkmusiccd,2262,0 +mellohimusicrecord,2262,0 +mellohimusicdisk,2262,0 +mellohimusicdisc,2262,0 +mellohimusiccd,2262,0 +pimusicrecord,2262,0 +pimusicdisk,2262,0 +pimusicdisc,2262,0 +pimusiccd,2262,0 +pinkmrecord,2262,0 +pinkmdisk,2262,0 +pinkmdisc,2262,0 +pinkmcd,2262,0 +mellohimrecord,2262,0 +mellohimdisk,2262,0 +mellohimdisc,2262,0 +mellohimcd,2262,0 +pimrecord,2262,0 +pimdisk,2262,0 +pimdisc,2262,0 +pimcd,2262,0 +pinkrecord,2262,0 +pinkdisk,2262,0 +pinkdisc,2262,0 +pinkcd,2262,0 +mellohirecord,2262,0 +mellohidisk,2262,0 +mellohicd,2262,0 +pirecord,2262,0 +pidisk,2262,0 +pidisc,2262,0 +picd,2262,0 +record7,2262,0 +disk7,2262,0 +disc7,2262,0 +cd7,2262,0 +7record,2262,0 +7disk,2262,0 +7disc,2262,0 +7cd,2262,0 +staldisc,2263,0 +blackmusicrecord,2263,0 +blackmusicdisk,2263,0 +blackmusicdisc,2263,0 +blackmusiccd,2263,0 +stalmusicrecord,2263,0 +stalmusicdisk,2263,0 +stalmusicdisc,2263,0 +stalmusiccd,2263,0 +blmusicrecord,2263,0 +blmusicdisk,2263,0 +blmusicdisc,2263,0 +blmusiccd,2263,0 +blackmrecord,2263,0 +blackmdisk,2263,0 +blackmdisc,2263,0 +blackmcd,2263,0 +stalmrecord,2263,0 +stalmdisk,2263,0 +stalmdisc,2263,0 +stalmcd,2263,0 +blmrecord,2263,0 +blmdisk,2263,0 +blmdisc,2263,0 +blmcd,2263,0 +blackrecord,2263,0 +blackdisk,2263,0 +blackdisc,2263,0 +blackcd,2263,0 +stalrecord,2263,0 +staldisk,2263,0 +stalcd,2263,0 +blrecord,2263,0 +bldisk,2263,0 +bldisc,2263,0 +blcd,2263,0 +record8,2263,0 +disk8,2263,0 +disc8,2263,0 +cd8,2263,0 +8record,2263,0 +8disk,2263,0 +8disc,2263,0 +8cd,2263,0 +straddisc,2264,0 +whitemusicrecord,2264,0 +whitemusicdisk,2264,0 +whitemusicdisc,2264,0 +whitemusiccd,2264,0 +stradmusicrecord,2264,0 +stradmusicdisk,2264,0 +stradmusicdisc,2264,0 +stradmusiccd,2264,0 +whmusicrecord,2264,0 +whmusicdisk,2264,0 +whmusicdisc,2264,0 +whmusiccd,2264,0 +whitemrecord,2264,0 +whitemdisk,2264,0 +whitemdisc,2264,0 +whitemcd,2264,0 +stradmrecord,2264,0 +stradmdisk,2264,0 +stradmdisc,2264,0 +stradmcd,2264,0 +whmrecord,2264,0 +whmdisk,2264,0 +whmdisc,2264,0 +whmcd,2264,0 +whiterecord,2264,0 +whitedisk,2264,0 +whitedisc,2264,0 +whitecd,2264,0 +stradrecord,2264,0 +straddisk,2264,0 +stradcd,2264,0 +whrecord,2264,0 +whdisk,2264,0 +whdisc,2264,0 +whcd,2264,0 +record9,2264,0 +disk9,2264,0 +disc9,2264,0 +cd9,2264,0 +9record,2264,0 +9disk,2264,0 +9disc,2264,0 +9cd,2264,0 +warddisc,2265,0 +darkgreenmusicrecord,2265,0 +darkgreenmusicdisk,2265,0 +darkgreenmusicdisc,2265,0 +darkgreenmusiccd,2265,0 +dgreenmusicrecord,2265,0 +dgreenmusicdisk,2265,0 +dgreenmusicdisc,2265,0 +dgreenmusiccd,2265,0 +darkgrmusicrecord,2265,0 +darkgrmusicdisk,2265,0 +darkgrmusicdisc,2265,0 +darkgrmusiccd,2265,0 +wardmusicrecord,2265,0 +wardmusicdisk,2265,0 +wardmusicdisc,2265,0 +wardmusiccd,2265,0 +dgrmusicrecord,2265,0 +dgrmusicdisk,2265,0 +dgrmusicdisc,2265,0 +dgrmusiccd,2265,0 +darkgreenmrecord,2265,0 +darkgreenmdisk,2265,0 +darkgreenmdisc,2265,0 +darkgreenmcd,2265,0 +dgreenmrecord,2265,0 +dgreenmdisk,2265,0 +dgreenmdisc,2265,0 +dgreenmcd,2265,0 +darkgrmrecord,2265,0 +darkgrmdisk,2265,0 +darkgrmdisc,2265,0 +darkgrmcd,2265,0 +wardmrecord,2265,0 +wardmdisk,2265,0 +wardmdisc,2265,0 +wardmcd,2265,0 +dgrmrecord,2265,0 +dgrmdisk,2265,0 +dgrmdisc,2265,0 +dgrmcd,2265,0 +darkgreenrecord,2265,0 +darkgreendisk,2265,0 +darkgreendisc,2265,0 +darkgreencd,2265,0 +dgreenrecord,2265,0 +dgreendisk,2265,0 +dgreendisc,2265,0 +dgreencd,2265,0 +darkgrrecord,2265,0 +darkgrdisk,2265,0 +darkgrdisc,2265,0 +darkgrcd,2265,0 +wardrecord,2265,0 +warddisk,2265,0 +wardcd,2265,0 +dgrrecord,2265,0 +dgrdisk,2265,0 +dgrdisc,2265,0 +dgrcd,2265,0 +record10,2265,0 +disk10,2265,0 +disc10,2265,0 +cd10,2265,0 +10record,2265,0 +10disk,2265,0 +10disc,2265,0 +10cd,2265,0 +11disc,2266,0 +crackedmusicrecord,2266,0 +crackedmusicdisk,2266,0 +crackedmusicdisc,2266,0 +crackedmusiccd,2266,0 +crackmusicrecord,2266,0 +crackmusicdisk,2266,0 +crackmusicdisc,2266,0 +crackmusiccd,2266,0 +11musicrecord,2266,0 +11musicdisk,2266,0 +11musicdisc,2266,0 +11musiccd,2266,0 +cmusicrecord,2266,0 +cmusicdisk,2266,0 +cmusicdisc,2266,0 +cmusiccd,2266,0 +crackedmrecord,2266,0 +crackedmdisk,2266,0 +crackedmdisc,2266,0 +crackedmcd,2266,0 +crackmrecord,2266,0 +crackmdisk,2266,0 +crackmdisc,2266,0 +crackmcd,2266,0 +11mrecord,2266,0 +11mdisk,2266,0 +11mdisc,2266,0 +11mcd,2266,0 +cmrecord,2266,0 +cmdisk,2266,0 +cmdisc,2266,0 +cmcd,2266,0 +crackedrecord,2266,0 +crackeddisk,2266,0 +crackeddisc,2266,0 +crackedcd,2266,0 +crackrecord,2266,0 +crackdisk,2266,0 +crackdisc,2266,0 +crackcd,2266,0 +crecord,2266,0 +cdisk,2266,0 +cdisc,2266,0 +ccd,2266,0 +record11,2266,0 +disk11,2266,0 +disc11,2266,0 +cd11,2266,0 +11record,2266,0 +11disk,2266,0 +11cd,2266,0 +waitdisc,2267,0 +waitmusicrecord,2267,0 +waitmusicdisk,2267,0 +waitmusicdisc,2267,0 +waitmusiccd,2267,0 +bluemusicrecord,2267,0 +bluemusicdisk,2267,0 +bluemusicdisc,2267,0 +bluemusiccd,2267,0 +12musicrecord,2267,0 +12musicdisk,2267,0 +12musicdisc,2267,0 +12musiccd,2267,0 +cyanmusicrecord,2267,0 +cyanmusicdisk,2267,0 +cyanmusicdisc,2267,0 +cyanmusiccd,2267,0 +waitmrecord,2267,0 +waitmdisk,2267,0 +waitmdisc,2267,0 +waitmcd,2267,0 +bluemrecord,2267,0 +bluemdisk,2267,0 +bluemdisc,2267,0 +bluemcd,2267,0 +12mrecord,2267,0 +12mdisk,2267,0 +12mdisc,2267,0 +12mcd,2267,0 +cyanmrecord,2267,0 +cyanmdisk,2267,0 +cyanmdisc,2267,0 +cyanmcd,2267,0 +waitrecord,2267,0 +waitdisk,2267,0 +waitcd,2267,0 +bluerecord,2267,0 +bluedisk,2267,0 +bluedisc,2267,0 +bluecd,2267,0 +cyanrecord,2267,0 +cyandisk,2267,0 +cyandisc,2267,0 +cyancd,2267,0 +record12,2267,0 +disk12,2267,0 +disc12,2267,0 +cd12,2267,0 +12record,2267,0 +12disk,2267,0 +12disc,2267,0 +12cd,2267,0 diff --git a/src/main/resources/lang.yml b/src/main/resources/lang.yml new file mode 100644 index 0000000..3d2dc6b --- /dev/null +++ b/src/main/resources/lang.yml @@ -0,0 +1,5 @@ +only-players: "Only players can run that command." +usage-format: "&6&lUSAGE &e» &7{message}" +no-permission: "&4&lERROR &e» You don't have permission to do that." +no-subs: "&4&lERROR &e» You don't have access to any sub-commands." +header-footer: "&7&m-----------------------------------" \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..42dd50b --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,4 @@ +main: com.alttd.altitudeapi.AltitudeAPI +name: AltitudeAPI +version: ${project.version} +author: Michael Ziluck \ No newline at end of file diff --git a/src/test/java/com/alttd/altitudeapi/commands/CommandLangTest.java b/src/test/java/com/alttd/altitudeapi/commands/CommandLangTest.java new file mode 100644 index 0000000..3f85ee2 --- /dev/null +++ b/src/test/java/com/alttd/altitudeapi/commands/CommandLangTest.java @@ -0,0 +1,39 @@ +package com.alttd.altitudeapi.commands; + +import java.io.File; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; + +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.assertTrue; + +public class CommandLangTest +{ + private FileConfiguration config; + + @Before + public void setup() + { + File file = new File("src/main/resources/lang.yml"); + + config = YamlConfiguration.loadConfiguration(file); + } + + @Test + public void test_file_contains_options() + { + Field[] fields = CommandLang.class.getDeclaredFields(); + + for (Field field : fields) + { + if (Modifier.isStatic(field.getModifiers())) + { + assertTrue("Missing value in file: " + field.getName(), config.contains(field.getName().toLowerCase().replace("_", "-"))); + } + } + } +}