################################################################################
 #
 #                                d R e g i o n s
 #
 #
 #   Authors: |Anthony|
 #   Version: 0.3
 #   dScript Version: 0.9.6-DEV_b140
 #
 #
 #   Dependencies:
 #
 #    - dWorldEditor
 #      - Integrates with region selection wand
 #      - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dWE/dWorldEditor.yml
 #
 #    - ConfigFileGenerator
 #      - Used to build default config files and data storage.
 #      - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/ConfigFileGenerator.yml
 #
 #    - Flags
 #      - All the flags for dRegions. It will be bundled in eventually.
 #      - https://github.com/AnthonyAMC/Public-Denizen-Scripts/blob/master/dRegions/flags.dscript
 #
 #_______________________________________________________________________________
 #
 #--- About dRegions
 #
 #  dRegions is an advanced region management and world protection system written
 # with the Denizen Scripting Engine. Heavily inspired by WorldGuard, the goal is
 # to have an extremely efficient events system supporting an exhaustive set of
 # region flags and configuration options. dRegions offers an intuitive command
 # interface and provides thorough TAB completion.
 #
 #
 #--- Installation & Setup
 #
 #  Install Flags, ConfigFileGenerator, dWorldEditor, and dRegions to your scripts
 # folder and reload scripts. /denizen reload scripts
 #
 #  All config and data storage files will be automatically generated in your
 # Denizen plugin folder. /plugins/Denizen/dRegions
 #
 #
 #--- Permissions & Commands
 #
 #  Here's a list of all the permissions and commands with a brief description
 # of each. More verbose usage info can be found in game. /drg help
 #
 #  dRegions provides thorough TAB completion! Use this to your benefit!
 #
 #  The permissions system isn't fully realized yet. Meanwhile, we have a list of
 # generic permissions to get you by.
 #
 #  /drg help [arg/#]      dregions.help                Specify a page number or command arg
 #  /drg define            dregions.define              Define a region
 #  /drg redefine          dregions.redefine            Update region to new selection
 #  /drg claim             dregions.claim               Claim the selected region
 #  /drg select            dregions.select              Select a region by id
 #  /drg remove            dregions.remove              Remove a region
 #  /drg list              dregions.list                List regions
 #  /drg info              dregions.info                See info on a region
 #  /drg addowner          dregions.addowner            Add a player or perm group as a region owner
 #  /drg removeowner       dregions.removeowner         Remove a player or perm group from region owner
 #  /drg addmember         dregions.addmember           Add a player or perm group as a region member
 #  /drg removemember      dregions.removemember        Remove a player or perm group from region member
 #  /drg flag              dregions.flag                Set region flags
 #  /drg setpriority       dregions.setpriority         Set region priority
 #  /drg setparent         dregions.setparent           Set region parent
 #  /drg teleport          dregions.teleport            Teleport to region
 #  /drg reload            dregions.reload              Reload all config files
 #  /drg restart           dregions.restart             Restart dRegions for whatever reason
 #                         dregions.admin               Override permission for all things dRegions
 #
 #                         dregions.invincible          Makes the player totally invincible
 #                         dregions.invincible.<cause>  Player can't be damaged by specific cause(s)
 #
 #--- Basic Usage Tutorial
 #
 #  After you've gotten installed, setup, and permissions assigned (op-only mode
 # is fine too), you will need to give yourself a region wand. /dwe wand
 #
 #  Mark your region selection using the wand as directed.
 #
 #  Define your region noting any owners (player or -g group) you want
 #   - /drg define myRegion notch herobrine -g members -g vip
 #
 #  Your region is now protected! *Still indev! Not all protections implemented!*
 #
 #  Set region priority
 #   - /drg setpriority myRegion 10
 #
 #  Set any region flags you need
 #   - /drg flag myRegion greeting Hello <player.name>!
 #
 #
 ################################################################################
 #
 #  dRegions World Events Script
 #
 #  This should cover all dRegions related world events.
 #
 #
 dRegions:
   type: world
   speed: 0
   debug: false
   events:
 ##################################################
 #
 #  World Events
 #
 #
     on server start:
     - run locally start delay:2t
 
     on world initializes:
     - run locally loadYaml instantly
 
     on script reload:
     - run locally start instantly
 
 
     on command:
     - if <context.server||false> {
       - queue clear
       }
     - define world '<player.world.name>'
     - define target '<c.command.to_lowercase> <c.raw_args.to_lowercase>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Commands'
       - inject s@dRegions_Flag_Commands p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Commands'
     - inject s@dRegions_Flag_Commands p:event
 
 
 #    on structure grows:
 #    - announce "Grew <context.structure>"
 #    - announce "<player.name||unknown>"
 
     on block ignites:
     - define world '<c.location.world.name>'
     - define target '<c.location.material.bukkit_enum>'
     - define readPath 'fire.<c.cause>'
     - if <c.cause> == flint_and_steel {
       - define cause 'Lighter'
       }
       else {
       - define cause 'Fire-Spread'
       }
 #    - define cause '<t[<c.cause.is[==].to[flint_and_steel]>]:Lighter||Fire-Spread>'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.%cause%.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_%cause%'
         - inject s@dRegions_Flag_%cause% p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_%cause%'
     - inject %FlagScript% p:event
 
     on block burns:
     - define world '<c.location.world.name>'
     - define target '<c.location.material.bukkit_enum>'
     - define readPath 'fire.destroyBlocks'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.fire-destroy.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Fire-Destroy'
         - inject s@dRegions_Flag_Fire-Destroy p:event-global
         }
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.fire-spread.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Fire-Spread'
         - inject s@dRegions_Flag_Fire-Spread p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Fire-Destroy'
     - inject s@dRegions_Flag_Fire-Destroy p:event
     - define FlagScript 's@dRegions_Flag_Fire-Spread'
     - inject s@dRegions_Flag_Fire-Spread p:event
 
     on ice forms:
     - define world '<c.location.world.name>'
     - define readPath 'blockform.ice'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.ice-form]||null>'
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Ice-Form'
       - inject s@dRegions_Flag_Ice-Form p:event-global
       - queue clear
       }
 #    - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
 #    - if %lCache% != null {
 #      - define orderedRegions '%lCache%'
 #      }
 #      else {
 #      - define regionPri 'li@'
 #      - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #        - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #        }
 #      - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #      - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
 #      }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Ice-Form'
     - inject s@dRegions_Flag_Ice-Form p:event
 
     on snow forms:
     - define world '<c.location.world.name>'
     - define target '<c.location.sub[0,1,0].material.bukkit_enum>'
     - define readPath 'blockform.snow'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.snow-fall.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Snow-Fall'
         - inject s@dRegions_Flag_Snow-Fall p:event-global
         }
       - queue clear
       }
 #    - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
 #    - if %lCache% != null {
 #      - define orderedRegions '%lCache%'
 #      }
 #      else {
 #      - define regionPri 'li@'
 #      - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #        - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #        }
 #      - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #      - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
 #      }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Snow-Fall'
     - inject s@dRegions_Flag_Snow-Fall p:event
 
     on soil fades:
     - define world '<c.location.world.name>'
     - define readPath 'blockfade.soil'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.soil-dry]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Soil-Dry'
       - inject s@dRegions_Flag_Soil-Dry p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Soil-Dry'
     - inject s@dRegions_Flag_Soil-Dry p:event
 
     on ice fades:
     - define world '<c.location.world.name>'
     - define readPath 'blockfade.ice'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.ice-melt]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Ice-Melt'
       - inject s@dRegions_Flag_Ice-Melt p:event-global
       - queue clear
       }
 #    - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
 #    - if %lCache% != null {
 #      - define orderedRegions '%lCache%'
 #      }
 #      else {
 #      - define regionPri 'li@'
 #      - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #        - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #        }
 #      - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #      - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
 #      }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Ice-Melt'
     - inject s@dRegions_Flag_Ice-Melt p:event
 
     on snow fades:
     - define world '<c.location.world.name>'
     - define readPath 'blockfade.snow'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.snow-melt]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Snow-Melt'
       - inject s@dRegions_Flag_Snow-Melt p:event-global
       - queue clear
       }
 #    - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
 #    - if %lCache% != null {
 #      - define orderedRegions '%lCache%'
 #      }
 #      else {
 #      - define regionPri 'li@'
 #      - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #        - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #        }
 #      - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #      - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
 #      }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Snow-Melt'
     - inject s@dRegions_Flag_Snow-Melt p:event
 
     on block spreads:
     - define mat '<c.material.bukkit_enum.split[_].last>'
     - if li@grass|mycel|mushroom|vines !contains %mat% queue clear
     - define world '<c.location.world.name>'
     - define readPath 'spread.%mat%'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.%mat%-spread]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_%mat%-Spread'
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_%mat%-Spread'
     - inject %FlagScript% p:event
 
     on liquid spreads:
     - if <c.location.material.bukkit_enum> == <c.destination.material.bukkit_enum> queue clear
     - define mat '<c.location.material.bukkit_enum.split[_].last>'
     - define target '<c.destination.material.bukkit_enum>'
     - define world '<c.location.world.name>'
     - define readPath 'spread.%mat%'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.destination.cuboids.include[<c.location.cuboids>].is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.%mat%-spread.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_%mat%-Spread'
         - inject s@dRegions_Flag_%mat%-Spread p:event-global
         }
       - queue clear
       }
     # Build list of dRegions for <c.destination> in priority order
     - define regionPri 'li@'
     - foreach <c.destination.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     # Block liquid from crossing region borders
     - if <c.location.cuboids.alphanumeric.unseparated||null> != <c.destination.cuboids.alphanumeric.unseparated||null> {
       # Build list of dRegions for <c.location> in priority order
       - define regionPri 'li@'
       - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define oldLoc '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]>'
       - if %oldLoc% != <def[orderedRegions].get[1]> {
         - determine cancelled
         }
       }
     - define FlagScript 's@dRegions_Flag_%mat%-Spread'
     - inject s@dRegions_Flag_%mat%-Spread p:event
 
     on lightning strikes:
     - define world '<c.world.name>'
     - define target '<c.location.below.material.bukkit_enum>'
     - define readPath 'lightning-strike'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.lightning-strikes.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Lightning-Strikes'
         - inject s@dRegions_Flag_Lightning-Strikes p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Lightning-Strikes'
     - inject s@dRegions_Flag_Lightning-Strikes p:event
 
     on leaves decay:
     - define world '<c.location.world.name>'
     - define readPath 'leaf-decay'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.leaf-decay]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Leaf-Decay'
       - inject s@dRegions_Flag_Leaf-Decay p:event-global
       - queue clear
       }
 #    - define lCache '<yaml[dRegions_%world%_cache].read[cache.locations.<c.location.simple>]||null>'
 #    - if %lCache% != null {
 #      - define orderedRegions '%lCache%'
 #      }
 #      else {
 #      - define regionPri 'li@'
 #      - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #        - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #        }
 #      - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #      - yaml set 'cache.locations.<c.location.simple>:%orderedRegions%' 'id:dRegions_%world%_cache'
 #      }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Leaf-Decay'
     - inject s@dRegions_Flag_Leaf-Decay p:event
 
     on portal created:
     - define world '<c.world.name.to_lowercase>'
     - define readPath 'portal.create'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
 
     on potion splash:
     # This will cancel the splash if any entity is in a protected region!
     - define world '<c.location.world.name>'
     - define cuboids '<c.entities.parse[location.cuboids].deduplicate>'
     - if <def[cuboids].is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.potion-throw]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - run s@dRegions_Flag_Potion-Throw msg delay:1t
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Potion-Throw'
       - inject s@dRegions_Flag_Potion-Throw p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Potion-Throw'
     - inject s@dRegions_Flag_Potion-Throw p:event
 
     on piston extends:
     - define world '<c.location.world.name>'
     - define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
     - if <c.blocks.include[%lastBlock%].parse[cuboids].is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pistons]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Pistons'
       - inject s@dRegions_Flag_Pistons p:event-global
       - queue clear
       }
     - if <c.location.cuboids.alphanumeric.unseparated||null> != <c.blocks.include[%lastBlock%].parse[cuboids].deduplicate.alphanumeric.unseparated||null> {
       - define regionPri 'li@'
       - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
       - define pistonCuboid '<def[orderedRegions].get[1]>'
       - foreach <c.blocks.include[%lastBlock%]> {
         - define cuboids <def[value].cuboids>
         - define regionPri 'li@'
         - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
           - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
           }
         - define nextLocCuboids '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
         - if <def[pistonCuboid].is[!=].to[<def[nextLocCuboids].get[1]>]> {
           - determine cancelled
           }
         }
       }
     - if <def[orederedRegions].exists.not> {
       - define regionPri 'li@'
       - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
       }
     - define FlagScript 's@dRegions_Flag_Pistons'
     - inject s@dRegions_Flag_Pistons p:event
 
     on piston retracts:
     - define world '<c.location.world.name>'
     - define lastBlock '<tern[<c.length.is[==].to[0]||true>]:<c.relative>||<c.relative.sub[<c.location>].add[<c.blocks.last>]>>'
     - if <c.blocks.include[%lastBlock%].parse[cuboids].is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pistons]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Pistons'
       - inject s@dRegions_Flag_Pistons p:event-global
       - queue clear
       }
     - if <c.location.cuboids.alphanumeric.unseparated||null> != <c.blocks.include[%lastBlock%].parse[cuboids].deduplicate.alphanumeric.unseparated||null> {
       - define regionPri 'li@'
       - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
       - define pistonCuboid '<def[orderedRegions].get[1]>'
       - foreach <c.blocks.include[%lastBlock%]> {
         - define cuboids <def[value].cuboids>
         - define regionPri 'li@'
         - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
           - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
           }
         - define nextLocCuboids '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
         - if <def[pistonCuboid].is[!=].to[<def[nextLocCuboids].get[1]>]> {
           - determine cancelled
           }
         }
       }
     - if <def[orederedRegions].exists.not> {
       - define regionPri 'li@'
       - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
       }
     - define FlagScript 's@dRegions_Flag_Pistons'
     - inject s@dRegions_Flag_Pistons p:event
 
 
 #
 #  END World Events
 ##################################################
 #
 #  Player Events
 #
 #
 #    on player clicks block:
 #    - narrate "item <c.item||i@air>"
 #    - narrate "mat <c.location.material.bukkit_enum||air>"
 #    - narrate "type <c.click_type||unknown>"
 #    - define world '<player.world.name.to_lowercase>'
 #    - define cuboids '<c.cuboids>'
 #    - inject s@dRegions p:event_PreProc_OrderRegionsGlobal
 #    - define allFlagScripts '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]]||li@>'
 
 #    - inject s@dRegions p:use_<c.item||null>
 #    - inject s@dRegions p:playerClick_<c.type||null>
 
     on player chats:
     - define world '<player.world.name>'
     - if <player.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Send-Chat'
       - inject s@dRegions_Flag_Send-Chat p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Send-Chat'
     - inject s@dRegions_Flag_Send-Chat p:event
 
     on player destroys vehicle:
     - define world '<player.world.name.to_lowercase>'
     - if <c.vehicle.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Vehicle-Destroy'
       - inject s@dRegions_Flag_Vehicle-Destroy p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.vehicle.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Vehicle-Destroy'
     - inject s@dRegions_Flag_Vehicle-Destroy p:event
 
     on player stands on:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define target '<c.location.material.bukkit_enum>'
     - define sameRegion 'true'
     - define rateLimit '<player.flag[dRegions.rateLimit.use-switches.%target%]||null>'
     - if %rateLimit% != null {
       - if %rateLimit% {
         - queue clear
         }
         else {
         - run s@dRegions_Flag_Use-Switches p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       }
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.use-switches.%target%]||null>'
       - if %cache% == false {
         - flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
         - run s@dRegions_Flag_use-switches p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define flagScript 's@dRegions_Flag_Use-Switches'
         - inject s@dRegions_Flag_Use-Switches p:event-global
         }
       - flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define flagScript 's@dRegions_Flag_Use-Switches'
     - inject s@dRegions_Flag_Use-Switches p:event
 
     on player right clicks block with boat:
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Vehicle-Place'
       - inject s@dRegions_Flag_Vehicle-Place p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Vehicle-Place'
     - inject s@dRegions_Flag_Vehicle-Place p:event
 
     on player right clicks with potion:
     - if !<c.item.potion_effect.is_splash||false> {
       - queue clear
       }
     - define world '<player.world.name>'
     - if <player.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Potion-Throw'
       - inject s@dRegions_Flag_Potion-Throw p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Potion-Throw'
     - inject s@dRegions_Flag_Potion-Throw p:event
 
     on player consumes potion:
     - define world '<player.world.name>'
     - if <player.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Potion-Drink'
       - inject s@dRegions_Flag_Potion-Drink p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Potion-Drink'
     - inject s@dRegions_Flag_Potion-Drink p:event
 
     on player right clicks block with armor_stand:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player right clicks block with monster_egg:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player throws hatching egg:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.egg.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.egg.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player right clicks:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> {
       - queue clear
       }
     - define target '<c.location.material.bukkit_enum||air>'
     - define item '<c.item.material.bukkit_enum||air>'
     - if %item% == air {
       - define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>'
       }
       else {
       - define eventObj '<s@dRegions_Map_Interactions.yaml_key[block_withItem.%target%]||li@>'
       - if <def[eventObj].split[/].get[2].as_list||li@> contains %item% {
         - define FlagScript '<def[eventObj].split[/].get[1]>'
         }
         else {
         - define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||null>'
         }
       }
     - if %FlagScript% == null {
       - queue clear
       }
     - define flag '<def[FlagScript].after_last[_]>'
 
     - if <c.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
       - define sameRegion 'true'
       - if %flag% == Build {
         - define rateLimit '<player.flag[dRegions.rateLimit.%flag%]||null>'
         }
         else {
         - define rateLimit '<player.flag[dRegions.rateLimit.%flag%.%target%]||null>'
         }
       - if %rateLimit% != null {
         - if %rateLimit% {
           - queue clear
           }
           else {
           - run s@dRegions_Flag_%flag% p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       }
       else {
       - define sameRegion 'false'
       }
 
     - define world '<player.world.name>'
     - define cuboids '<c.cuboids||<player.location.cursor_on[5].cuboids||li@>>'
     - if <def[cuboids].is_empty||true> {
       - if %flag% == Build {
         - inject %FlagScript% p:event-global
         - queue clear
         }
       - define cache '<player.flag[dRegions.cache.%world%.__global__.%flag%.%target%]||null>'
       - if %cache% == false {
         - if %sameRegion% flag <player> dRegions.rateLimit.%flag%.%target%:false d:10s
         - run s@dRegions_Flag_%flag% p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - inject s@dRegions_Flag_%flag% p:event-global
         }
       - if %sameRegion% flag <player> dRegions.rateLimit.%flag%.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - inject %FlagScript% p:event
 
     on player right clicks npc:
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_NPC-Interact'
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_NPC-Interact'
     - inject s@dRegions_Flag_NPC-Interact p:event
 
     on player right clicks entity:
     - if <c.entity.is_player> || <c.entity.is_npc> || <c.entity.entity_type> == item_frame {
       - queue clear
       }
     - define target '<c.entity.entity_type>'
     - define rateLimit '<player.flag[dRegions.rateLimit.entity-interact.%target%]||null>'
     - if %rateLimit% != null {
       - if %rateLimit% {
         - queue clear
         }
         else {
         - run s@dRegions_Flag_Entity-Interact p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       }
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.entity-interact.%target%]||null>'
       - if %cache% == false {
         - flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
         - run s@dRegions_Flag_Entity-Interact p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Entity-Interact'
         - inject s@dRegions_Flag_Entity-Interact p:event-global
         }
       - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Interact'
     - inject s@dRegions_Flag_Entity-Interact p:event
 
     on player enters bed:
     # Do we need to fire events for region enter, exit, and toggle?
     # This is a cheat so we don't have to mess about with firing a region entry event.
     - if <c.location.cuboids.alphanumeric.unseparated||null> != <player.location.cuboids.alphanumeric.unseparated||null> {
       - determine cancelled
       }
     - define world '<player.world.name>'
     - if <c.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Sleep'
       - inject s@dRegions_Flag_Sleep p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Sleep'
     - inject s@dRegions_Flag_Sleep p:event
 
 # Looks like this isn't needed since the cuboid enter/exit event fires
 #    on player enters vehicle:
 #    # Should be doing a check if the cart is in a different cuboid before firing
 #    # the regionEnter and regionToggle events.
 #    # Do we need to fire events for regionExit as well?
 #    # Make vehicle-enter flag for this event!
 #    - if <c.vehicle.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
 #      - queue clear
 #      }
 #    - define world '<player.world.name.to_lowercase>'
 #    - define isEnter ''
 #    - if <c.vehicle.location.cuboids.is_empty||true> {
 #      - define FlagScript 's@dRegions_Flag_Sleep'
 #      - inject %FlagScript% p:event-global
 #      - queue clear
 #      }
 #    - define regionPri 'li@'
 #    - foreach <c.vehicle.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #      - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #      }
 #    - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #    - foreach <server.flag[dRegions_FlagMap].filter[contains_any[regionEnter|regionToggle]].parse[after[/]].alphanumeric.parse[split[/].get[2]]> {
 #      - define FlagScript '%value%'
 #      - inject %value% p:event
 #      }
 
 
     on player enters notable cuboid:
     # Should we fire an event when the player exits the global region?
 #    - if <c.from.cuboids.is_empty> {
 #      - event 'player exits notable cuboid' 'context:cuboids|<c.from.cuboids.escaped>|from|<c.from>|to|<c.to>' save:exit
 #      - if <entry[exit].determinations.get[1].is[==].to[cancelled]||false> determine cancelled
 #      }
     - flag <player> dRegions.rateLimit:!
     - define world '<player.world.name.to_lowercase>'
     - define isEnter ''
     - define cuboids '<c.cuboids.unescaped.as_list>'
     - if <def[cuboids].is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Entry'
       - inject s@dRegions_Flag_Entry p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entry'
     - inject s@dRegions_Flag_Entry p:event
 
     on player exits notable cuboid:
     - define world '<player.world.name.to_lowercase>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Exit'
       - inject s@dRegions_Flag_Exit p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Exit'
     - inject s@dRegions_Flag_Exit p:event
     - event 'player enters notable cuboid' 'context:cuboids|<c.to.cuboids.escaped>|from|<c.from>|to|<c.to>' save:enter
     - if <entry[enter].determinations.get[1]||null> == cancelled {
       - determine cancelled
       }
 
     on player breaks block:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - define target '<c.material.bukkit_enum>'
     - if <c.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
       - define sameRegion 'true'
       - define rateLimit '<player.flag[dRegions.rateLimit.build]||null>'
       - if %rateLimit% != null {
         - if !%rateLimit% {
           - run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       - define rateLimit '<player.flag[dRegions.rateLimit.block-break.%target%]||null>'
       - if %rateLimit% != null {
         - if %rateLimit% {
           - queue clear
           }
           else {
           - run s@dRegions_Flag_Block-Break p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       }
       else {
       - define sameRegion 'false'
       }
     - if <c.cuboids.is_empty||true> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.build]||null>'
       - if %cache% == false {
         - if %sameRegion% flag <player> dRegions.rateLimit.build:false d:10s
         - run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Build'
         - inject s@dRegions_Flag_Build p:event-global
         }
       - if %sameRegion% flag <player> dRegions.rateLimit.build:true d:10s
       - define cache '<player.flag[dRegions.cache.%world%.__global__.block-break.%target%]||null>'
       - if %cache% == false {
         - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
         - run s@dRegions_Flag_block-break p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_block-break'
         - inject s@dRegions_Flag_block-break p:event-global
         }
       - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
     - define FlagScript 's@dRegions_Flag_Block-Break'
     - inject s@dRegions_Flag_Block-Break p:event
 
     on player places block:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - define target '<c.material.bukkit_enum>'
     - if <c.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
       - define sameRegion 'true'
       - define rateLimit '<player.flag[dRegions.rateLimit.build]||null>'
       - if %rateLimit% != null {
         - if !%rateLimit% {
           - run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       - define rateLimit '<player.flag[dRegions.rateLimit.block-place.%target%]||null>'
       - if %rateLimit% != null {
         - if %rateLimit% {
           - queue clear
           }
           else {
           - run s@dRegions_Flag_Block-Place p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       }
       else {
       - define sameRegion 'false'
       }
     - if <c.cuboids.is_empty||true> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.build]||null>'
       - if %cache% == false {
         - if %sameRegion% flag <player> dRegions.rateLimit.build:false d:10s
         - run s@dRegions_Flag_Build p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Build'
         - inject s@dRegions_Flag_Build p:event-global
         }
       - if %sameRegion% flag <player> dRegions.rateLimit.build:true d:10s
       - define cache '<player.flag[dRegions.cache.%world%.__global__.block-place.%target%]||null>'
       - if %cache% == false {
         - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
         - run s@dRegions_Flag_block-place p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_block-place'
         - inject s@dRegions_Flag_block-place p:event-global
         }
       - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
     - define FlagScript 's@dRegions_Flag_Block-Place'
     - inject s@dRegions_Flag_Block-Place p:event
 
     on player empties bucket:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.relative.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Bucket-Empty'
       - inject s@dRegions_Flag_Bucket-Empty p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.relative.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Bucket-Empty'
     - inject s@dRegions_Flag_Bucket-Empty p:event
 
     on player fills bucket:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Bucket-Fill'
       - inject s@dRegions_Flag_Bucket-Fill p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Bucket-Fill'
     - inject s@dRegions_Flag_Bucket-Fill p:event
 
     on player drops item:
     - define world '<player.world.name>'
     - define cuboids '<player.location.cuboids.include[<c.location.cuboids>].deduplicate>'
     - if <def[cuboids].is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Player-Drops'
       - inject s@dRegions_Flag_Player-Drops p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Player-Drops'
     - inject s@dRegions_Flag_Player-Drops p:event
 
     on player picks up item:
     - define world '<player.world.name>'
     - define cuboids '<player.location.cuboids.include[<c.location.cuboids>].deduplicate>'
     - if <def[cuboids].is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Player-Pickup'
       - inject s@dRegions_Flag_Player-Pickup p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Player-Pickup'
     - inject s@dRegions_Flag_Player-Pickup p:event
 
     on player places hanging:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - define FlagScript 's@dRegions_Flag_Hanging-Place'
       - inject s@dRegions_Flag_Hanging-Place p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
     - define FlagScript 's@dRegions_Flag_Hanging-Place'
     - inject s@dRegions_Flag_Hanging-Place p:event
 
     on player right clicks at armor_stand:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player right clicks item_frame:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player damages item_frame:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player damages player:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<c.entity.world.name>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.pvp]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - remove <c.projectile||li@>
         - run s@dRegions_Flag_PVP msg delay:1t
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_PVP'
       - inject s@dRegions_Flag_PVP p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_PVP'
     - inject s@dRegions_Flag_PVP p:event
 
     on player damages armor_stand:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<c.entity.world.name>'
     - define FlagScript 's@dRegions_Flag_Build'
     - if <c.entity.location.cuboids.is_empty||true> {
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - inject %FlagScript% p:event
 
     on player damages entity:
     - if li@armor_stand|player|item_frame contains <c.entity.prefix> {
       - queue clear
       }
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define target '<c.entity.entity_type>'
     - if <c.entity.location.cuboids.alphanumeric.unseparated||null> == <player.location.cuboids.alphanumeric.unseparated||null> {
       - define rateLimit '<player.flag[dRegions.rateLimit.pve.%target%]||null>'
       - if %rateLimit% != null {
         - if %rateLimit% {
           - queue clear
           }
           else {
           - run s@dRegions_Flag_pve p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
           - determine cancelled
           }
         }
       }
     - define world '<c.entity.world.name>'
     - define player '<c.damager>'
     - define puuid '<c.damager.uuid>'
     - if <c.entity.location.cuboids.is_empty> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.pve.%target%]||null>'
       - if %cache% == false {
         - flag <player> dRegions.rateLimit.FLAG.%target%:false d:10s
         - run s@dRegions_Flag_pve p:msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_pve'
         - inject s@dRegions_Flag_pve p:event-global
         }
       - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_PVE'
     - inject %FlagScript% p:event
 
     on player left clicks block:
     - if <c.relative.material.name> != fire {
       - queue clear
       }
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.relative.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.relative.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player clicks block with bone_meal:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - if <c.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
 
     on player damaged:
     - define rateLimit '<player.flag[dRegions.rateLimit.player-damage.<c.cause>]||null>'
     - if %rateLimit% != null {
       - if %rateLimit% {
         - queue clear
         }
         else {
         - determine cancelled
         }
       }
     - if ( <player.has_permission[dregions.invincible]> || <player.has_permission[dregions.invincible.<c.cause>]> ) && !<player.is_op> {
       - flag <player> dRegions.rateLimit.player-damage.%target%:false d:5s
       - adjust <player> 'fire_time:0'
       - determine cancelled
       }
     - define world '<c.entity.world.name>'
     - define target '<c.cause>'
     - define puuid '<player.uuid>'
     - define readPath 'player-damage'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.entity.location.cuboids.is_empty||true> {
       - define cache '<player.flag[dRegions.cache.%world%.__global__.player-damage.%target%]||null>'
       - if %cache% == false {
         - flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
         - adjust <player> 'fire_time:0'
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Player-Damage'
         - inject s@dRegions_Flag_Player-Damage p:event-global
         }
       - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Player-Damage'
     - inject s@dRegions_Flag_Player-Damage p:event
 
     on player changes food level:
     - define world '<player.world.name>'
     - if <player.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Hunger'
       - inject s@dRegions_Flag_Hunger p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Hunger'
     - inject s@dRegions_Flag_Hunger p:event
 
     on player teleports:
     - if <c.cause> != ender_pearl queue cleard
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<player.world.name>'
     - define cuboids '<c.origin.cuboids.include[<c.destination.cuboids>].deduplicate>'
     - if <def[cuboids].is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Enderpearl'
       - inject s@dRegions_Flag_Enderpearl p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[cuboids].parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Enderpearl'
     - inject s@dRegions_Flag_Enderpearl p:event
 
     on player respawns:
     - if <player.has_flag[dRegions_Respawn]> {
       - adjust <player> 'health:<player.health.max>'
       - determine passively '<player.flag[dRegions_Respawn].as_location||<world.spawn_location>>'
       - wait 10t
       - flag <player> 'dRegions_Respawn:!'
       }
 
 #
 #  END Player Events
 ##################################################
 #
 #  Mob Events
 #
     on entity targets entity:
     - if <c.target.prefix> == player {
       - queue clear
       }
     - define world '<c.entity.world.name>'
     - define attacker '<c.entity>'
     - define defender '<c.target>'
     - define atarget '<c.entity.entity_type>'
     - define dtarget '<c.target.entity_type>'
     - if <c.target.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Mob-Attack'
       - inject s@dRegions_Flag_Mob-Attack p:event-global
       - define FlagScript 's@dRegions_Flag_EVE'
       - inject s@dRegions_Flag_EVE p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.target.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Mob-Attack'
     - inject s@dRegions_Flag_Mob-Attack p:event
     - define FlagScript 's@dRegions_Flag_EVE'
     - inject s@dRegions_Flag_EVE p:event
 
     on entity targets player:
     - define target '<c.entity.entity_type>'
     - define rateLimit '<c.target.flag[dRegions.rateLimit.mob-target.%target%]||null>'
     - if %rateLimit% != null {
       - if %rateLimit% {
         - queue clear
         }
         else {
         - determine cancelled
         }
       }
     - define player '<c.target>'
     - define world '<c.entity.world.name>'
     - define attacker '<c.entity>'
     - if <c.target.location.cuboids.is_empty||true> {
       - define cache '<c.target.flag[dRegions.cache.%world%.__global__.flag.%target%]||null>'
       - if %cache% == false {
         - flag <c.target> dRegions.rateLimit.mob-target.%target%:false d:10s
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Mob-Target'
         - inject s@dRegions_Flag_Mob-Target p:event-global
         }
       - flag <c.target> dRegions.rateLimit.mob-target.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.target.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Mob-Target'
     - inject s@dRegions_Flag_Mob-Target p:event
 
 #  This needs to be rewritten cause... idk
 #
 #    on entity damaged by block_explosion:
 #    - announce "block_explosion <c.cause>"
 #    - define world '<c.entity.world.name>'
 #    - if <c.entity.location.cuboids.is_empty||true> {
 #      - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #      - inject s@dRegions_Flag_Entity-Explode p:event-global
 #      - queue clear
 #      }
 #    - define regionPri 'li@'
 #    - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
 #      - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
 #      }
 #    - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #    - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #    - inject s@dRegions_Flag_Entity-Explode p:event
 
     on entity damages entity:
     - if li@<c.damager.prefix>|<c.entity.prefix> contains player {
       - queue clear
       }
     - define world '<c.entity.world.name>'
     - define attacker '<c.damager>'
     - define defender '<c.entity>'
     - define atarget '<c.damager.entity_type>'
     - define dtarget '<c.entity.entity_type>'
     - if <c.entity.location.cuboids.is_empty||true> {
 #      - if <c.cause> == entity_explosion {
 #        - define target '%atarget%'
 #        - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-attack.%atarget%]||null>'
 #        - if %cache% != null {
 #          - if !%cache% {
 #            - determine cancelled
 #            }
 #          }
 #          else {
 #          - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #          - inject s@dRegions_Flag_Entity-Explode p:event-global
 #          }
 #        }
       - define FlagScript 's@dRegions_Flag_Mob-Attack'
       - inject s@dRegions_Flag_Mob-Attack p:event-global
       - define FlagScript 's@dRegions_Flag_EVE'
       - inject s@dRegions_Flag_EVE p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #    - if <c.cause> == entity_explosion {
 #      - define target '%atarget%'
 #      - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #      - inject s@dRegions_Flag_Entity-Explode p:event
 #      }
     - define FlagScript 's@dRegions_Flag_Mob-Attack'
     - inject s@dRegions_Flag_Mob-Attack p:event
     - define FlagScript 's@dRegions_Flag_EVE'
     - inject s@dRegions_Flag_EVE p:event
 
 
     on entity damages player:
     - if <c.damager.prefix> == player {
       - queue clear
       }
     - define target '<c.damager.entity_type>'
     - define rateLimit '<c.entity.flag[dRegions.rateLimit.mob-damage.%target%]||null>'
     - if %rateLimit% != null {
       - if %rateLimit% {
         - queue clear
         }
         else {
         - determine cancelled
         }
       }
     - define world '<c.entity.world.name>'
     - define attacker '<c.damager>'
     - define player '<c.entity>'
     - if <c.entity.location.cuboids.is_empty||true> {
 #      - if <c.cause> == entity_explosion {
 #        - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #        - inject s@dRegions_Flag_Entity-Explode p:event-global
 #        }
       - define cache '<c.entity.flag[dRegions.cache.%world%.__global__.flag.%target%]||null>'
       - if %cache% == false {
         - flag <c.entity> dRegions.rateLimit.mob-damage.%target%:false d:10s
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Mob-Damage'
         - inject s@dRegions_Flag_Mob-Damage p:event-global
         }
       - flag <c.entity> dRegions.rateLimit.mob-damage.%target%:true d:10s
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 #    - if <c.cause> == entity_explosion {
 #      - define FlagScript 's@dRegions_Flag_Entity-Explode'
 #      - inject s@dRegions_Flag_Entity-Explode p:event
 #      }
     - define FlagScript 's@dRegions_Flag_Mob-Damage'
     - inject s@dRegions_Flag_Mob-Damage p:event
 
     on player dies:
     - define world '<c.entity.world.name>'
     - define target '<c.entity.entity_type>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - run player:<c.entity> s@dRegions_Flag_Spawn p:event-global def:%world% delay:1t
       - define FlagScript 's@dRegions_Flag_Player-KeepItems'
       - inject s@dRegions_Flag_Player-KeepItems p:event-global
       - define FlagScript 's@dRegions_Flag_Player-Drops-OnDeath'
       - inject s@dRegions_Flag_Player-Drops-OnDeath p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - run player:<c.entity> s@dRegions_Flag_Spawn p:event def:%world%|<def[orderedRegions].escaped> delay:1t
     - define FlagScript 's@dRegions_Flag_Player-KeepItems'
     - inject s@dRegions_Flag_Player-KeepItems p:event
     - define FlagScript 's@dRegions_Flag_Player-Drops-OnDeath'
     - inject s@dRegions_Flag_Player-Drops-OnDeath p:event
 
     on entity dies:
     - if <c.entity.prefix> == player {
       - queue clear
       }
     - define world '<c.entity.world.name>'
     - define target '<c.entity.entity_type>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-drops-ondeath.%target%]||null>'
       - if %cache% == false {
         - determine no_drops
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Entity-Drops-OnDeath'
         - inject s@dRegions_Flag_Entity-Drops-OnDeath p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.entity.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Drops-OnDeath'
     - inject s@dRegions_Flag_Entity-Drops-OnDeath p:event
 
     on entity spawns:
     - define world '<c.entity.world.name>'
     - define target '<c.entity.entity_type>'
     - if <c.entity.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-spawn.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Mob-Spawn'
         - inject s@dRegions_Flag_Mob-Spawn p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Mob-Spawn'
     - inject s@dRegions_Flag_Mob-Spawn p:event
 
     on entity enters portal:
     - define world '<c.location.world.name.to_lowercase>'
     - define readPath 'portal.<tern[<c.entity.is_player>]:player||entity>-enter'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
 
     on entity changes soil:
     - define world '<c.location.world.name>'
     - define type '<c.entity.prefix>'
     - define readPath 'trample-crops.%type%'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.trample-crops-%type%]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Trample-Crops-%type%'
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Trample-Crops-%type%'
     - inject %FlagScript% p:event
 
     on falling_block changes block:
     - define mat '<c.entity.fallingblock_material.bukkit_enum>'
     - if li@sand|gravel !contains %mat% queue clear
     - define world '<c.location.world.name>'
     - define readPath 'physics.%mat%'
     - define FlagScript 's@dRegions_Flag_Falling-%mat%'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.falling-%mat%]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Falling-%mat%'
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Falling-%mat%'
     - inject %FlagScript% p:event
 
     on entity changes block:
     - if <c.old_material.bukkit_enum> == soil || li@falling_block|creeper|primed_tnt contains <c.entity.entity_type> {
       - queue clear
       }
     - define world '<c.location.world.name>'
     - define readPath 'entity.changeBlock'
     - define target '<c.entity.entity_type>'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-grief.%target%]||null>'
       - if %cache% == false {
 #        - run s@dRegions_Flag_Entity-Grief offthread delay:1t def:<c.entity.uuid>
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Entity-Grief'
         - inject s@dRegions_Flag_Entity-Grief p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Grief'
     - inject s@dRegions_Flag_Entity-Grief p:event
 
     on entity forms block:
 #    - if <c.entity.has_flag[dRegions_NoGrief]> determine cancelled
     - if <server.has_flag[dRegions.EntityGrief.<c.entity.uuid>]> {
       - determine cancelled
       }
     - define world '<c.location.world.name>'
     - define readPath 'entity.changeBlock'
     - define target '<c.entity.entity_type||other>'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-grief.%target%]||null>'
       - if %cache% == false {
         - run s@dRegions_Flag_Entity-Grief offthread delay:1t def:<c.entity.uuid>
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Entity-Grief'
         - inject s@dRegions_Flag_Entity-Grief p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Grief'
     - inject s@dRegions_Flag_Entity-Grief p:event
 
     on entity explodes:
     - define world '<c.location.world.name>'
     - define readPath 'entity.explode'
     - define attacker '<c.entity>'
     - define target '<c.entity.entity_type>'
     - inject s@dRegions p:event_PreProc_Config
     - if <c.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.entity-explode.%target%]||null>'
       - if %cache% == false {
         - determine cancelled
         }
       - if %cache% == null {
         - define FlagScript 's@dRegions_Flag_Entity-Explode'
         - inject s@dRegions_Flag_Entity-Explode p:event-global
         }
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Explode'
     - inject s@dRegions_Flag_Entity-Explode p:event
 
     on entity breaks hanging:
     - if <c.entity.prefix> == player {
       - queue clear
       }
     - define world '<c.entity.world.name>'
     - define type '<c.hanging.entity_type.replace[_]>'
     - define readPath 'entity-break-%type%'
     - inject s@dRegions p:event_PreProc_Config-NoTarget
     - if <c.hanging.location.cuboids.is_empty||true> {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.__global__.entity-break-%type%]||null>'
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define FlagScript 's@dRegions_Flag_Entity-Break-%type%'
       - inject %FlagScript% p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.hanging.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Entity-Break-%type%'
     - inject %FlagScript% p:event
 
     on player breaks hanging:
     - if <player.has_permission[dRegions.admin]> || <player.is_op> queue clear
     - define world '<c.entity.world.name>'
     - if <c.hanging.location.cuboids.is_empty||true> {
       - define FlagScript 's@dRegions_Flag_Build'
       - inject s@dRegions_Flag_Build p:event-global
       - define FlagScript 's@dRegions_Flag_Hanging-Break'
       - inject s@dRegions_Flag_Hanging-Break p:event-global
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <c.hanging.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - define FlagScript 's@dRegions_Flag_Build'
     - inject s@dRegions_Flag_Build p:event
     - define FlagScript 's@dRegions_Flag_Hanging-Break'
     - inject s@dRegions_Flag_Hanging-Break p:event
 
 
 
 #
 #  END Mob Events
 ##################################################
 #
 #  Utility Subscripts
 #
 
   testinga:
     - ^define world '<player.location.world.name.to_lowercase>'
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]]>|__global__ {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - ^narrate %orderedRegions%
 
 
   testingb:
     - ^define world '<player.location.world.name.to_lowercase>'
     - define regionPri 'li@'
     - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - foreach <server.flag[dRegions_FlagMap].filter[contains_any[regionEnter|regionToggle]].parse[after[/]].alphanumeric.parse[split[/].get[2]]> {
       - define FlagScript '%value%'
       }
 
   testingc:
     - if ( a == a ) && ( b == b ) && ( c == d ) {
       - narrate "true"
       }
       else {
       - narrate "false"
       }
 
 
 
   start:
     - inject locally loadYaml
     - define flags '<server.list_flags.filter[starts_with[dRegions]]>'
     - foreach %flags% {
       - flag server %value%:!
       }
     - define flagScripts '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]]||li@>'
     - flag server 'dRegions_Flags:!'
     - flag server 'dRegions_Flags:|:%flagScripts%'
 #    - define flagMap 'li@'
 #    - foreach '%flagScripts%' {
 #      - define flagMap '<def[flagMap].include[<def[value].yaml_key[event_hook]||none>/<def[value].yaml_key[event_priority]||none>]>/%value%'
 #      }
     - flag server 'dRegions_FlagMap:!'
 #    - flag server 'dRegions_FlagMap:|:%flagMap%'
 
 
   event_PreProc_Config:
   # Reusable code block injected from events.
   # This pre-processor handles events in the global and world config files before
   # any regions even get a chance. World configs are processed before global.
   # This way worlds can deny events that global allows, but global has ultimate
   # control for denying events. Denying an event takes precedence over allowing.
   # Default is 'true' on most events for this reason.
   #
   # Events that take a block list are handled here as well. Blocklists can
   # operate in whitelist or blacklist modes.
   #
   # Blacklist mode.
   # When an event is set to 'false' and no blocks are specified in the
   # blocklist, it will always cancel the event. If there are blocks specified,
   # it will only cancel events involving those blocks listed.
   #
   # Whitelist mode.
   # When an event is set to 'true' and no blocks are specified in the blocklist,
   # it will always allow the event. If there are blocks specifed, it will only
   # allow events involving those blocks listed.
   #
     - define targetList '<yaml[dRegions_%world%_config].read[config.%readPath%-list]||li@>'
     - if <yaml[dRegions_%world%_config].read[config.%readPath%]||true> {
       - if !<def[targetList].is_empty> && %targetList% !contains %target% {
         - determine cancelled
         }
       }
       else {
       - if <def[targetList].is_empty> || %targetList% contains %target% {
         - determine cancelled
         }
       }
 
     - define targetList '<yaml[dRegions_global_config].read[config.%readPath%-list]||li@>'
     - if <yaml[dRegions_global_config].read[config.%readPath%]||true> {
       - if !<def[targetList].is_empty> && %targetList% !contains %target% {
         - determine cancelled
         }
       }
       else {
       - if <def[targetList].is_empty> || %targetList% contains %target% {
         - determine cancelled
         }
       }
 
   event_PreProc_Config-NoTarget:
     - if !<yaml[dRegions_%world%_config].read[config.%readPath%]> {
       - determine cancelled
       }
 
     - if !<yaml[dRegions_global_config].read[config.%readPath%]> {
       - determine cancelled
       }
 
 
   loadYaml:
   # Reloads the yaml files and generates default files if they don't exist.
   # Rewrites config files that do not match internal version number!
     - announce "<&b>dRegions<&co><&3> Loading system config files..." to_console
     - define world 'global'
     - define file 'config'
     - if !<server.has_file[dRegions/config.yml]> {
       - if <player.is[!=].to[null]||false> {
         - flag <player> ConfigFileGeneratorNotify:true
         - inject locally createConfigFile instantly
         - flag <player> ConfigFileGeneratorNotify:!
         - run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> config file!'
         }
         else {
         - inject locally createConfigFile
         }
       - announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> config file!" to_console
       }
     - if <yaml.list.contains[dRegions_global_config]> {
       - yaml unload 'id:dRegions_global_config'
       }
     - yaml 'load:dRegions/config.yml' 'id:dRegions_global_config'
 
     - if <yaml[dRegions_<def[world]>_config].read[config.version].is[!=].to[<s@dRegions_Configurations.yaml_key[config.version]>]||false> {
       - define isUpdate ''
       - if <player.is[!=].to[null]||false> {
         - flag <player> ConfigFileGeneratorNotify:true
         - inject locally createConfigFile
         - flag <player> ConfigFileGeneratorNotify:!
         - run s@dRegions_Msg 'def:<&7><&o>Updated <&f><&o>%world%<&7><&o> config file!'
         }
         else {
         - inject locally createConfigFile
         }
       - define isUpdate:!
       - announce "<&b>dRegions<&co> <&7><&o>Updated <&f><&o>%world%<&7><&o> config file!" to_console
       }
 
     - foreach <server.list_worlds.parse[name.to_lowercase]> {
       - define world '<def[value]>'
       - define file 'worlds/%world%/config'
 
       - if !<server.has_file[dRegions/%file%.yml]> {
         - if <player.is[!=].to[null]||false> {
           - flag <player> ConfigFileGeneratorNotify:true
           - inject locally createConfigFile
           - flag <player> ConfigFileGeneratorNotify:!
           - run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> config file!'
           }
           else {
           - inject locally createConfigFile
           }
         - announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> config file!" to_console
         }
       - if <yaml.list.contains[dRegions_%world%_config]> {
         - yaml unload 'id:dRegions_%world%_config'
         }
       - yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_config'
 
       - if <yaml[dRegions_<def[world]>_config].read[config.version].is[!=].to[<s@dRegions_Configurations.yaml_key[config.version]>]||false> {
         - define isUpdate ''
         - if <player.is[!=].to[null]||false> {
           - flag <player> ConfigFileGeneratorNotify:true
           - inject locally createConfigFile
           - flag <player> ConfigFileGeneratorNotify:!
           - run s@dRegions_Msg 'def:<&7><&o>Updated <&f><&o>%world%<&7><&o> config file!'
           }
           else {
           - inject locally createConfigFile
           }
         - define isUpdate:!
         - announce "<&b>dRegions<&co> <&7><&o>Updated <&f><&o>%world%<&7><&o> config file!" to_console
         }
 
       - define file 'worlds/%world%/regions'
       - if !<server.has_file[dRegions/%file%.yml]> {
         - define region '__global__'
         - if <player.is[!=].to[null]||false> {
           - flag <player> ConfigFileGeneratorNotify:true
           - inject locally createRegionFile
           - flag <player> ConfigFileGeneratorNotify:!
           - run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> regions file!'
           }
           else {
           - inject locally createRegionFile
           }
         - announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> regions file!" to_console
         }
       - if <yaml.list.contains[dRegions_%world%_regions]> {
         - yaml unload 'id:dRegions_%world%_regions'
         }
       - yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_regions'
 
       - define file 'worlds/%world%/inventories'
       - if !<server.has_file[dRegions/%file%.yml]> {
         - if <player.is[!=].to[null]||false> {
           - flag <player> ConfigFileGeneratorNotify:true
           - inject locally createInventoryFile
           - flag <player> ConfigFileGeneratorNotify:!
           - run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> regions file!'
           }
           else {
           - inject locally createInventoryFile
           }
         - announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> inventory file!" to_console
         }
       - if <yaml.list.contains[dRegions_%world%_inventories]> {
         - yaml unload 'id:dRegions_%world%_inventories'
         }
       - yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_inventories'
 
       - define file 'worlds/%world%/cache'
       - if !<server.has_file[dRegions/%file%.yml]> {
         - if <player.is[!=].to[null]||false> {
           - flag <player> ConfigFileGeneratorNotify:true
           - inject locally createCacheFile
           - flag <player> ConfigFileGeneratorNotify:!
           - run s@dRegions_Msg 'def:<&7><&o>Created <&f><&o>%world%<&7><&o> cache file!'
           }
           else {
           - inject locally createCacheFile
           }
         - announce "<&b>dRegions<&co> <&7><&o>Created <&f><&o>%world%<&7><&o> cache file!" to_console
         }
       - if <yaml.list.contains[dRegions_%world%_cache]> {
         - yaml unload 'id:dRegions_%world%_cache'
         }
       - yaml 'load:dRegions/%file%.yml' 'id:dRegions_%world%_cache'
       }
     - announce "<&b>dRegions<&co><&a> System config files Loaded!" to_console
 
 
   reloadYaml:
   # A simpler reload
     - announce "<&b>dRegions<&co><&3> Reloading system config files..." to_console
     - run s@dRegions_Msg 'def:<&7><&o>Reloading system config files...'
     - if <yaml.list.contains[dRegions_global_config]> {
       - yaml unload 'id:dRegions_global_config'
       }
     - yaml 'load:dRegions/config.yml' 'id:dRegions_global_config'
     - foreach <server.list_worlds.parse[name.to_lowercase]> {
       - define world '<def[value]>'
       - if <yaml.list.contains[dRegions_%world%_config]> {
         - yaml unload 'id:dRegions_%world%_config'
         }
       - yaml 'load:dRegions/worlds/%world%/config.yml' 'id:dRegions_%world%_config'
       - if <yaml.list.contains[dRegions_%world%_regions]> {
         - yaml unload 'id:dRegions_%world%_regions'
         }
       - yaml 'load:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - if <yaml.list.contains[dRegions_%world%_inventories]> {
         - yaml unload 'id:dRegions_%world%_inventories'
         }
       - yaml 'load:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
       - if <yaml.list.contains[dRegions_%world%_cache]> {
         - yaml unload 'id:dRegions_%world%_cache'
         }
       - yaml 'load:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
       }
     - announce "<&b>dRegions<&co><&a> System config files Loaded!" to_console
     - run s@dRegions_Msg 'def:<&7><&o>System config files Loaded!'
 
 
   createConfigFile:
     - define readID 'dRegions_Configurations'
     - define writeID 'dRegions_%world%_config'
     - if !<yaml.list.contains[%readID%]> {
       - yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
       }
     - if !<yaml.list.contains[%readID%]> {
       - announce to_console "Loaded <script.relative_filename>"
       }
     - yaml create 'id:%writeID%'
     - define readPath '%readID%.config'
     - define writePath 'config'
     - if <def[isUpdate].exists||false> {
       - run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|true instantly
       }
       else {
       - run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
       }
     - yaml unload 'id:%readID%'
     - yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
 
 
   createRegionFile:
     - define readID 'dRegions_Configurations'
     - define writeID 'dRegions_%world%_regions'
     - if !<yaml.list.contains[%readID%]> {
       - yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
       }
     - yaml create 'id:%writeID%'
     - define readPath '%readID%.regions.__global__'
     - define writePath 'regions.%region%'
     - run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
     - yaml unload 'id:%readID%'
     - yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
 
 
   createInventoryFile:
     - define readID 'dRegions_Configurations'
     - define writeID 'dRegions_%world%_inventories'
     - if !<yaml.list.contains[%readID%]> {
       - yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
       }
     - yaml create 'id:%writeID%'
     - define readPath '%readID%.inventories'
     - define writePath 'inventories'
     - run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
     - yaml unload 'id:%readID%'
     - yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
 
 
   createCacheFile:
     - define readID 'dRegions_Configurations'
     - define writeID 'dRegions_%world%_cache'
     - if !<yaml.list.contains[%readID%]> {
       - yaml fix_formatting 'load:<script.relative_filename>' 'id:%readID%'
       }
     - yaml create 'id:%writeID%'
     - define readPath '%readID%.cache'
     - define writePath 'cache'
     - run s@ConfigFileGenerator def:%readID%|%writeID%|%readPath%|%writePath%|false|false|false instantly
     - yaml unload 'id:%readID%'
     - yaml 'savefile:dRegions/%file%.yml' 'id:%writeID%'
 
 
   createRegionEntry:
     - if !<yaml.list.contains[dRegions_%world%_regions]> {
       yaml 'load:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       }
     - yaml set 'regions.%name%.type:cuboid' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.priority:0' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.flags:|:' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.owners:|:' 'id:dRegions_%world%_regions'
     - foreach <def[ownerGroups]||li@> {
       - yaml set 'regions.%name%.owners.groups:->:%value%' 'id:dRegions_%world%_regions'
       }
     - foreach <def[ownerPlayers]||li@> {
       - yaml set 'regions.%name%.owners.players:->:%value%' 'id:dRegions_%world%_regions'
       }
     - yaml set 'regions.%name%.members:|:' 'id:dRegions_%world%_regions'
     - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
     - note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
 
   clearCache:
     - define region %1%
     - define world %2%
     - define flag %3%
     - define type '<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
     - if %type% == list {
       - define type '<s@dRegions_Flag_%flag%.yaml_key[flag_parent].as_script.yaml_key[flag_type]>'
       }
     - if %region% == '__global__' {
       - inject locally clearCacheGlobal
       - queue clear
       }
     - define cuboid '<cu@dregions_%world%_%region%.as_cuboid>'
     - define children '<yaml[dRegions_%world%_regions].read[regions.%region%.children]||li@>'
     - define overlaps '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]].filter[intersects[%cuboid%]].parse[replace[cu@dregions_%world%_]]||li@>'
 
     - if li@boolean|state-withTarget contains %type% {
       - yaml set 'cache.%type%.%region%.%flag%:!' 'id:dRegions_%world%_cache'
       - foreach <def[children].include[%overlaps%].include[__global__]> {
         - yaml set 'cache.%type%.%value%.%flag%:!' 'id:dRegions_%world%_cache'
         }
       }
       else if li@state-withGroup|state-withTarget-withGroup|state-withTargetString-withGroup contains %type% {
       - define players '<def[cuboid].list_players>'
       - foreach %players% {
         - flag <player> dRegions.cache.%world%.%region%.%flag%:!
         }
       }
 
   clearCacheGlobal:
     - define allRegions '<yaml[dRegions_%world%_regions].list_keys[regions]||li@>'
     - if li@boolean|state-withTarget contains %type% {
       - foreach %allRegions% {
         - yaml set 'cache.%type%.%value%.%flag%:!' 'id:dRegions_%world%_cache'
         }
       }
       else if li@state-withGroup|state-withTarget-withGroup|state-withTargetString-withGroup contains %type% {
       - foreach <server.list_online_players> {
         - flag <player> dRegions.cache.%world%.%region%.%flag%:!
         }
       }
 
 #
 #  END Utility Subscripts
 ##################################################
 #
 #  Message format
 #
 
 
 dRegions_Msg:
   type: item
   speed: 0
   debug: false
   material: i@human_skull
   display name: "<&4>  [<&6>dRegions<&4>]"
   lore:
   - <&5>Click for Help
   script:
     - ^define text '<&4>[<&6>dRegions<&4>]'
     - ^define hover '<&chr[007B]><i@dRegions_Msg.json><&chr[007D]>'
     - ^define click '/dregions help'
     - ^define button "text:'%text%',clickEvent:<&chr[007B]>action:run_command,value:'%click%'<&chr[007D]>,hoverEvent:<&chr[007B]>action:show_item,value:'%hover%'<&chr[007d]>"
     - ^define spacer "text:'  '"
     - ^define msg "text:'%1%'"
     - ^if <player.is_player||false> {
       - execute as_server "tellraw <player.name> <&chr[007B]>text:'',extra:[<&chr[007B]>%button%<&chr[007D]>,<&chr[007B]>%spacer%<&chr[007D]>,<&chr[007B]>%msg%<&chr[007D]>]<&chr[007D]>"
       }
       else {
       - announce to_console "%1%"
       }
 
 
 ################################################################################
 #
 #  dRegions Command Script Container
 #
 # This script covers all dRegions commands
 #
 #
 #
 #--------------------------------------
 #
 #  dRegions Command Script Basics
 #
 # The basic stuff required in a command script container
 #
 dRegions_Commands:
   type: command
   speed: 0
   debug: false
   name: dregions
   description: Denizen Regions Manager
   usage: /dregions
   aliases:
   - drg
   allowed help:
   - determine true
 
   commandArgs:
     help:
       usage: '/drg help <&lt>arg/<&ns><&gt>'
       permissions: []
     about:
       usage: '/drg about'
       permissions: []
     reload:
       usage: '/drg reload'
       permissions: []
     restart:
       usage: '/drg restart'
       permissions: []
     define:
       usage: '/drg define [ID] (g:group) (player)'
       permissions: []
     redefine:
       usage: '/drg redefine [ID]'
       permissions: []
     claim:
       usage: '/drg claim [ID]'
       permissions: []
     select:
       usage: '/drg select [ID] -w world'
       permissions: []
     info:
       usage: '/drg info [ID] -w world'
       permissions: []
     addowner:
       usage: '/drg addowner [ID] g:group player -w world'
       permissions: []
     removeowner:
       usage: '/drg removeowner [ID] g:group player -w world'
       permissions: []
     addmember:
       usage: '/drg addmember [ID] g:group player -w world'
       permissions: []
     removemember:
       usage: '/drg removemember [ID] g:group player -w world'
       permissions: []
     list:
       usage: '/drg list (page<&ns>) -h -r region -w world -p player'
       permissions: []
     flag:
       usage: '/drg flag [ID] [flag] [value] -g group -w world'
       permissions: []
     setpriority:
       usage: '/drg setpriority [ID] [<&ns>]'
       permissions: []
     setparent:
       usage: '/drg setparent [ID] [parent]'
       permissions: []
     teleport:
       usage: '/drg teleport [ID] -w world'
       permissions: []
     remove:
       usage: '/drg remove [ID] -w world'
       permissions: []
 
   tab complete:
     - define args '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
     - define arg '<c.args.get[1]||null>'
     - if <def[arg].is[==].to[null]>
       || !<def[args].contains[%arg%]> {
       - inject locally tab_arg_1
       }
       else {
       - inject locally tab_%arg%
       }
     - determine '<def[result]||li@>'
 
   script:
     - define command '<c.args.get[1].escaped||help>'
     - define args '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
     - if !<def[args].contains[%command%]> {
       - inject locally help
       }
       else {
       - inject locally %command%
       }
 
 
 #
 #  END dRegions Command Script Basics
 #--------------------------------------
 #
 #  dRegions Command TAB Completion
 #
 # Each of these subscripts handles TAB completion for the positional argument.
 #
 #
   tab_arg_1:
     # This Excludes args from the original args
     - foreach %args% {
       - if !<player.has_permission[dregions.%value%]||<player.is_op||false>> {
         - define args '<def[args].exclude[%value%]||%args%>'
         }
       }
     - if <def[args].is_empty||true> {
       - define result 'li@'
       }
       else {
       - define result '<def[args].filter[starts_with[%arg%]]||li@> '
       - if <def[result].is_empty||true> {
         - define result '%args%'
         }
       }
 
   tab_help:
     - define spaces '<c.raw_args.to_list.count[ ]||0>'
     - if <def[spaces].is[==].to[0]> {
       - define result 'help [command]'
       }
       else if <def[spaces].is[==].to[1]> {
       - define result 'li@'
       - foreach %args% {
         - if <player.has_permission[dregions.%value%]||<player.is_op||false>> {
           - define result '<def[result].include[%value%]||%result%>'
           }
           else {
           - foreach next
           }
         }
       - if <c.args.get[2].is[!=].to[null]||false> {
         - define result '<def[args].filter[starts_with[<c.args.get[2]>]]||li@>'
         - if <def[result].is_empty> {
           - foreach %args% {
             - if <player.has_permission[dregions.%value%]||<player.is_op||false>> {
               - define result '<def[result].include[%value%]||%result%>'
               }
               else {
               - foreach next
               }
             }
           }
         }
       }
 
   tab_about:
     - define result 'li@'
 
   tab_reload:
     - define result 'li@'
 
   tab_restart:
     - define result 'li@'
 
   tab_define:
   # /drg define [ID] (g:group) (player)
     - if <player.has_permission[dregions.define]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - if <def[spaces].is[==].to[0]> {
         - define result 'define [ID]'
         }
 
         else if <def[spaces].is[==].to[1]> {
         - if <c.args.get[2].is[==].to[null]||true> {
           - define result '[ID] (g:group) (player)'
           }
           else {
           - define result '<c.args.get[2]> (g:group) (player)'
           }
         }
 
         else if <def[spaces].is[OR_MORE].than[2]> {
         - define owners '<c.args.remove[1|2]||li@>'
         - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
           - define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
           }
         - define owner '<def[owners].last||li@>'
         - if <def[owner].starts_with[g:]||false> {
           - define group '<def[owner].replace[g:]>'
           - define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
           - if <def[groups].is_empty> {
             - define groups '<server.list_permission_groups||li@>'
             }
           - define result '<def[groups].parse[replace[regex:^].with[g:]]>'
           }
           else {
           - define result '<server.match_player[%owner%].name||null>'
           - if <def[result].is[==].to[null]||true> {
             - define result '<server.list_online_players.parse[name]>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_redefine:
   # /drg redefine [ID]
     - if <player.has_permission[dregions.redefine]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||true>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[redefine ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_claim:
     - if <player.has_permission[dregions.claim]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[claim ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_select:
   # /drg select [ID] -w world
     - if <player.has_permission[dregions.select]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[select ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_info:
   # /drg info [ID] -w world
     - if <player.has_permission[dregions.info]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[info ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_addowner:
   # /drg addowner [ID] g:group player -w world
     - if <player.has_permission[dregions.addowner]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[addowner ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped||null>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else if <def[spaces].is[OR_MORE].than[2]> {
         - define owners '<c.args.remove[1|2]||li@>'
         - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
           - define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
           }
         - define owner '<def[owners].last||li@>'
         - if <def[owner].starts_with[g:]||false> {
           - define group '<def[owner].replace[g:]>'
           - define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
           - if <def[groups].is_empty> {
             - define groups '<server.list_permission_groups.alphanumeric||li@>'
             }
           - define result '<def[groups].parse[replace[regex:^].with[g:]]>'
           }
           else {
           - define result '<server.match_player[%owner%].name||null>'
           - if <def[result].is[==].to[null]||true> {
             - define result '<server.list_online_players.parse[name].alphanumeric>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_removeowner:
   # /drg removeowner [ID] g:group player -w world
     - if <player.has_permission[dregions.removeowner]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[removeowner ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else if <def[spaces].is[OR_MORE].than[2]> {
         - define owners '<c.args.remove[1|2]||li@>'
         - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
           - define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
           }
         - define owner '<def[owners].last||li@>'
         - if <def[owner].starts_with[g:]||false> {
           - define group '<def[owner].replace[g:]>'
           - define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
           - if <def[groups].is_empty> {
             - define groups '<server.list_permission_groups.alphanumeric||li@>'
             }
           - define result '<def[groups].parse[replace[regex:^].with[g:]]>'
           }
           else {
           - define result '<server.match_player[%owner%].name||null>'
           - if <def[result].is[==].to[null]||true> {
             - define result '<server.list_online_players.parse[name].alphanumeric>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_addmember:
   # /drg addmember [ID] g:group player -w world
     - if <player.has_permission[dregions.addmember]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[addmember ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else if <def[spaces].is[OR_MORE].than[2]> {
         - define members '<c.args.remove[1|2]||li@>'
         - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
           - define members '<def[members].remove[<def[members].find[-w]>|<def[members].find[-w].add[1].as_int>]||li@>'
           }
         - define member '<def[members].last||li@>'
         - if <def[member].starts_with[g:]||false> {
           - define group '<def[member].replace[g:]>'
           - define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
           - if <def[groups].is_empty> {
             - define groups '<server.list_permission_groups.alphanumeric||li@>'
             }
           - define result '<def[groups].parse[replace[regex:^].with[g:]]>'
           }
           else {
           - define result '<server.match_player[%owner%].name||null>'
           - if <def[result].is[==].to[null]||true> {
             - define result '<server.list_online_players.parse[name].alphanumeric>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_removemember:
   # /drg removemember [ID] g:group player -w world
     - if <player.has_permission[dregions.removemember]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
       - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - foreach %regions% {
           - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
             - define regions '<def[regions].exclude[%value%]||%regions%>'
             }
           }
         }
       - if <def[spaces].is[==].to[0]> {
         - define result '<def[regions].parse[replace[regex:^].with[removemember ]]>'
         }
         else if <def[spaces].is[==].to[1]> {
         - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
         - if <def[result].is_empty||true> {
           - define result '%regions%'
           }
         }
         else if <def[spaces].is[OR_MORE].than[2]> {
         - define members '<c.args.remove[1|2]||li@>'
         - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
           - define members '<def[members].remove[<def[members].find[-w]>|<def[members].find[-w].add[1].as_int>]||li@>'
           }
         - define member '<def[members].last||li@>'
         - if <def[member].starts_with[g:]||false> {
           - define group '<def[member].replace[g:]>'
           - define groups '<server.list_permission_groups.filter[starts_with[%group%]]||li@>'
           - if <def[groups].is_empty> {
             - define groups '<server.list_permission_groups.alphanumeric||li@>'
             }
           - define result '<def[groups].parse[replace[regex:^].with[g:]]>'
           }
           else {
           - define result '<server.match_player[%owner%].name||null>'
           - if <def[result].is[==].to[null]||true> {
             - define result '<server.list_online_players.parse[name].alphanumeric>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_list:
     - define result 'li@'
 
   tab_flag:
   # TODO
   # /drg flag [ID] [flag] [value] -g group -w world
     - if <player.has_permission[dregions.flag]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - if <def[spaces].is[==].to[0]> {
         - define result 'flag [ID]'
         }
         else if <def[spaces].is[==].to[1]> {
         - if <c.args.get[2].is[==].to[null]||true> {
           - define result '[ID]'
           }
           else if <c.args.get[2].is[==].to[-w]||false> {
           - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
           }
           else if <context.server.not> {
           - define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].alphanumeric||li@>'
           - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
             - foreach %regions% {
               - if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
                 - define regions '<def[regions].exclude[%value%]||%regions%>'
                 }
               }
             }
           - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
           - if <def[result].is_empty||true> {
             - define result '%regions%'
             }
           }
           else {
           - define result 'li@'
           }
         }
         else if <def[spaces].is[==].to[2]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - if <c.args.get[3].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
           else if <c.args.get[2].is[!=].to[null]||false> {
           - define allFlags '<server.flag[dRegions_Flags].parse[name.split[_].get[3].to_lowercase].alphanumeric||li@>'
           - if <c.args.get[3].is[==].to[-w]||false> {
             - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
             - if <c.args.get[3].is[!=].to[null]||false> {
               - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
               }
             - if <def[result].is_empty||true> {
               - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
               }
             }
             else if <c.args.get[3].is[!=].to[null]||false> {
             - define result '<def[allFlags].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
             - if <def[result].is_empty||true> {
               - define result '<def[allFlags]||li@>'
               }
             }
             else {
             - if <def[result].is_empty||true> {
               - define result '<def[allFlags]||li@>'
               }
             }
           }
         }
         else if <def[spaces].is[==].to[3]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
           - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].alphanumeric||li@>'
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<def[regions]||li@>'
             }
           }
           else if <c.args.get[3].is[==].to[-w]||false> {
           - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]].parse[replace[regex:^].with[-w ]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
           else if <c.args.get[4].is[==].to[-w]||false> {
           - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
           }
         }
         else if <def[spaces].is[==].to[4]> {
         - if <c.args.get[4].is[==].to[-w]||false> {
           - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||<player.world.name.to_lowercase||null>>'
           - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].alphanumeric||li@>'
           - if <c.args.get[5].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[5].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
           else {
           - define allFlags '<server.flag[dRegions_Flags].parse[name.split[_].get[3].to_lowercase].alphanumeric||li@>'
           - if <c.args.get[5].is[!=].to[null]||false> {
             - define result '<def[allFlags].filter[starts_with[<c.args.get[5].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<def[allFlags]||li@>'
             }
           }
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_setpriority:
   # /drg remove [ID] -w world
     - if <player.has_permission[dregions.setpriority]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - if <def[spaces].is[==].to[0]> {
         - define result 'setpriority [ID]'
         }
         else if <def[spaces].is[==].to[1]> {
         - if <c.args.get[2].is[==].to[null]||true> {
           - define result '[ID]'
           }
           else if <c.args.get[2].is[==].to[-w]||false> {
           - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
           }
           else if <context.server.not> {
           - define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
           - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
             - foreach %regions% {
               - if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
                 - define regions '<def[regions].exclude[%value%]||%regions%>'
                 }
               }
             - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
             }
             else {
             - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||%regions%>'
             - if <def[result].is_empty> {
               - define result '%regions%'
               }
             }
           }
           else {
           - define result 'li@'
           }
         }
         else if <def[spaces].is[==].to[2]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - if <c.args.get[3].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
           else {
           - if <c.args.get[3].is[MATCHES].to[number]> {
             - define result '<c.args.get[3]>'
             }
             else if <c.args.get[3].is[==].to[-w]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
             }
             else {
             - define result '<&ns>'
             }
           }
         }
         else if <def[spaces].is[==].to[3]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define regions '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
             - define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
             - if <def[result].is_empty||true> {
               - define result '%regions%'
               }
             }
             else {
             - define result '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
             }
           }
           else if <c.args.get[3].is[==].to[-w]||false> {
           - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
           }
           else {
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
             }
             else {
             - define result '<server.list_worlds.parse[name].parse[replace[regex:^].with[-w ]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]||li@>'
             }
           }
         }
         else if <def[spaces].is[==].to[4]> {
         - if <c.args.get[2].is[==].to[-w]||false>
           || <c.args.get[3].is[==].to[-w]||false> {
           - if <c.args.get[5].is[MATCHES].to[number]> {
             - define result '<c.args.get[5]>'
             }
             else {
             - define result '<&ns>'
             }
           }
           else if <c.args.get[4].is[==].to[-w]> {
           - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
   tab_setparent:
   # TODO
     - define result 'li@'
 
   tab_teleport:
   # TODO
     - define result 'li@'
 
   tab_remove:
   # /drg remove [ID] -w world
     - if <player.has_permission[dregions.remove]||<player.is_op||false>> {
       - define spaces '<c.raw_args.to_list.count[ ]||0>'
       - if <def[spaces].is[==].to[0]> {
         - define result 'remove [ID] -w world'
         }
         else if <def[spaces].is[==].to[1]> {
         - if <c.args.get[2].is[==].to[null]||true> {
           - define result '[ID]'
           }
           else if <c.args.get[2].is[==].to[-w]||false> {
           - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
           }
           else if <context.server.not> {
           - define regions '<yaml[dRegions_<player.world.name.to_lowercase>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
           - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
             - foreach %regions% {
               - if <proc[dRegions_IsOwner].context[%value%|<player.world.name.to_lowercase>|<player>].not> {
                 - define regions '<def[regions].exclude[%value%]||%regions%>'
                 }
               }
             }
           - define result '<def[regions].filter[starts_with[<c.args.get[2].escaped>]]||li@>'
           - if <def[result].is_empty||true> {
             - define result '%regions%'
             }
           }
           else {
           - define result 'li@'
           }
         }
         else if <def[spaces].is[==].to[2]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - if <c.args.get[3].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[3].escaped>]]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
           else {
           - define result '<server.list_worlds.parse[name.to_lowercase].parse[replace[regex:^].with[-w ]]>'
           }
         }
         else if <def[spaces].is[==].to[3]> {
         - if <c.args.get[2].is[==].to[-w]||false> {
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define regions '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
             - define result '<def[regions].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
             - if <def[result].is_empty||true> {
               - define result '%regions%'
               }
             }
             else {
             - define result '<yaml[dRegions_<c.args.get[3].escaped>_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
             }
           }
           else {
           - if <c.args.get[4].is[!=].to[null]||false> {
             - define result '<server.list_worlds.parse[name.to_lowercase].filter[starts_with[<c.args.get[4].escaped>]]||li@>'
             }
             else {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           - if <def[result].is_empty||true> {
             - define result '<server.list_worlds.parse[name.to_lowercase]||li@>'
             }
           }
         }
         else {
         - define result 'li@'
         }
       }
       else {
       - define result 'li@'
       }
 
 
 #
 #  END dRegions Command TAB Completion
 #--------------------------------------
 #
 #  dRegions Command Arguments
 #
 # Each of these subscripts is an argument for the root command.
 #
   help:
     - define arg '<c.args.get[2].escaped||null>'
     - if <def[args].contains[%arg%]||false> {
       - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%arg%.usage]||No help for you!>'
       - queue clear
       }
     - if <player.has_permission[dRegions.admin]||<player.is_op||<context.server||false>>> {
       - inject locally msgsHelpAdmin
       }
       else {
       - inject locally msgsHelpUser
       }
     - inject locally msgsFooter
     - queue clear
 
   about:
     - inject locally msgsHelpUser
     - inject locally msgsFooter
     - queue clear
 
   reload:
     - if !<player.has_permission[dRegions.reload]||<player.is_op||<context.server||false>>> {
       - inject locally help
       - queue clear
       }
     - inject s@dRegions p:reloadYaml instantly
 #    - run s@dRegions_Msg 'def:<&7><&o>System files loaded!'
 
   restart:
     - if !<player.has_permission[dRegions.restart]||<player.is_op||<context.server||false>>> {
       - inject locally help
       - queue clear
       }
     - run s@dRegions p:start instantly
 
 
   define:
   # /drg define [ID] (g:group) (player)
     - inject locally prerun instantly
     # Check for existing region
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]||true>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists]> {
       - run s@dRegions_Msg 'def:<&c>There is already a region by this name!'
       - queue clear
       }
     # Check for overlapping regions
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
         - run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
         - queue clear
         }
       }
     # Parse any declared owners
     - define owners '<c.args.remove[1|2].replace[:].with[;]||li@>'
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define owners '<def[owners].remove[<def[owners].find[-w]>|<def[owners].find[-w].add[1].as_int>]||li@>'
       }
     - define ownerGroups li@
     - define ownerPlayers li@
     - foreach %owners% {
       - if <def[value].starts_with[g;]||false> {
         - define ownerGroups '<def[ownerGroups].include[<def[value].replace[g;]>]||%ownerGroups%>'
         }
         else {
         - if !<def[value].as_player.is[!=].to[null]||false> {
           - foreach next
           }
         - define ownerPlayers '<def[ownerPlayers].include[<def[value].as_player.uuid>]||%ownerPlayers%>'
         }
       }
     # Automatically add the player that defined the region as the owner
     - if <yaml[dregions_global_config].read[config.regions.ownerOnDefine].is[==].to[true]||false> {
       - if <def[ownerPlayers].contains[<player.uuid>].not||false> {
         - define ownerPlayers '<def[ownerPlayers].include[<player.uuid>]||%ownerPlayers%>'
         }
       }
     # Create the region
     - inject s@dRegions p:createRegionEntry instantly
     - run s@dRegions_Msg 'def:<&7><&o>Created %name% in %world%'
 
   redefine:
   # /drg redefine [ID]
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Don't redefine global type regions
     - if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
       - run s@dRegions_Msg 'def:<&c>You can not redefine global regions!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Check for overlapping regions
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
         - run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
         - queue clear
         }
       }
     # Update the region
     - yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
     - yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
     - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
     - note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
     - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> updated to selection'
 
   claim:
   # /drg claim [ID]
     - inject locally prerun instantly
     # Check Global region limits
     - define globalRegionLimit '<yaml[dregions_global_config].read[config.regions.claim.max-region-count-per-player.default]||0>'
     - if <def[globalRegionLimit].is[MORE].than[0]> {
       - define playerGlobalRegions 'li@'
       - foreach <server.list_worlds.parse[name.to_lowercase]> {
         - define thisWorld '%value%'
         - foreach '<yaml[dRegions_%thisWorld%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
           - define region '%value%'
           - if <proc[dRegions_IsOwner].context[<def[region]>|<def[thisWorld]>|<player>]||false> {
             - define playerGlobalRegions '<def[playerGlobalRegions].include[<def[region]>]||<def[playerGlobalRegions]>>'
             }
           }
         }
       - if <def[playerGlobalRegions].size.is[OR_MORE].than[%globalRegionLimit%]> {
         - run s@dRegions_Msg 'def:<&c>You already have <def[playerGlobalRegions].size> total regions!'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     # Check World region limits
     - define worldRegionLimit '<yaml[dregions_%world%_config].read[config.regions.claim.max-region-count-per-player.default]||0>'
     - if <def[worldRegionLimit].is[MORE].than[0]> {
       - define playerWorldRegions 'li@'
       - foreach '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
         - define region '%value%'
         - if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>]||false> {
           - define playerWorldRegions '<def[playerWorldRegions].include[<def[region]>]||<def[playerWorldRegions]>>'
           }
         }
       - if <def[playerWorldRegions].size.is[OR_MORE].than[%worldRegionLimit%]> {
         - run s@dRegions_Msg 'def:<&c>You already have <def[playerWorldRegions].size> regions in this world!'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     # Check selection volume
     - define globalClaimVol '<yaml[dregions_global_config].read[config.regions.claim.max-volume]||0>'
     - inject s@dWE_Commands p:selection_Size instantly
     - if <def[globalClaimVol].is[MORE].than[0]> {
       - if <def[size].is[MORE].than[%globalClaimVol%]> {
         - run s@dRegions_Msg 'def:<&c>Your selection exceeds the global limit!'
         - run s@dRegions_Msg 'def:<&7><&o>Selected <&8>(<&7><&o>%size%<&8>) <&7><&o>Limit <&8>(<&7><&o>%globalClaimVol%<&8>) <&7><&o>Over <&8>(<&7><&o><def[size].sub[%globalClaimVol%].as_int><&8>)'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     - define worldClaimVol '<yaml[dregions_%world%_config].read[config.regions.claim.max-volume]||0>'
     - if <def[worldClaimVol].is[MORE].than[0]> {
       - if <def[size].is[MORE].than[%worldClaimVol%]> {
         - run s@dRegions_Msg 'def:<&c>Your selection exceeds the world limit!'
         - run s@dRegions_Msg 'def:<&7><&o>Selected <&8>(<&7><&o>%size%<&8>) <&7><&o>Limit <&8>(<&7><&o>%worldClaimVol%<&8>) <&7><&o>Over <&8>(<&7><&o><def[size].sub[%worldClaimVol%].as_int><&8>)'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     # Check inside existing/owned region
     - if '<yaml[dregions_global_config].read[config.regions.claim.only-inside-existing-regions]||false>' {
       - if <def[playerWorldRegions].exists.not> {
         - define playerWorldRegions 'li@'
         - foreach '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>' {
           - define region '%value%'
           - if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>]||false> {
             - define playerWorldRegions '<def[playerWorldRegions].include[<def[region]>]||<def[playerWorldRegions]>>'
             }
           }
         }
       - define cuboids '<def[playerWorldRegions].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]||false]||li@>'
       - foreach %cuboids% {
         - if <def[pos1].as_location.is_within[%value%]>
           && <def[pos2].as_location.is_within[%value%]> {
           - define isWithin ''
           - foreach stop
           }
         }
       - if <def[isWithin].exists.not> {
         - run s@dRegions_Msg 'def:<&c>You may only claim regions within land you own'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists]> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
         - run s@dRegions_Msg 'def:<&c>You can not redefine global regions!'
         - queue clear
         }
       - run s@dRegions_Msg 'def:<&c>Region already exists!'
       - run s@dRegions_Msg 'def:<&7>You must want to update the region'
       - define update ''
       }
     # Check for overlapping regions
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%world%|<player>]> {
         - run s@dRegions_Msg 'def:<&c>Region selection contains unowned regions!'
         - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
           - queue clear
           }
         - run s@dRegions_Msg 'def:<&c>But you are an admin so it is ok!'
         }
       }
     # Update the region
     - if <def[update].exists||false> {
       - yaml set 'regions.%name%.min:<def[selectedCuboid].min.simple>' 'id:dRegions_%world%_regions'
       - yaml set 'regions.%name%.max:<def[selectedCuboid].max.simple>' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - note cu@<def[selectedCuboid].min.simple>|<def[selectedCuboid].max.simple> 'as:dregions_%world%_%name%'
       - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> updated to selection'
       }
       else {
       - define ownerPlayers 'li@<player.uuid>'
       - inject s@dRegions p:createRegionEntry instantly
       - run s@dRegions_Msg 'def:<&7><&o>Created %name% in %world%'
       }
 
   select:
   # /drg select [ID]
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Don't select global type regions
     - if <yaml[dRegions_%world%_regions].read[regions.%name%.type].is[==].to[global]||false> {
       - run s@dRegions_Msg 'def:<&c>You can not select global regions!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     - define min '<yaml[dRegions_%world%_regions].read[regions.%name%.min].as_location.simple||null>'
     - define max '<yaml[dRegions_%world%_regions].read[regions.%name%.max].as_location.simple||null>'
     - flag <player> 'dWEWand_Type:cuboid'
     - flag <player> dWEWand:!
     - flag <player> dWEWand:|:%min%|%max%
     - run s@dRegions_Msg 'def:<&7><&o>Selected <&f><&o>%name%'
 
   info:
   # /drg info [ID] -w world
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region named %name%!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     - inject locally regionInfo instantly
     - define msgsHeaderTitle '<&7>Region Info<&co> <&e>%name% <&8><&lb><&7>%world%<&8><&rb>'
     - inject locally msgsHeader instantly
     - narrate "<&5><el@val[|].pad_right[3]><&7>Type<&co> <&f>%type% <&8><&lb><&7><&o><def[pos1].split[,].remove[4].comma_separated.replace[ ]> <&8><&pipe> <&7><&o><def[pos2].split[,].remove[4].comma_separated.replace[ ]><&8><&rb> <&lb><&7><&o>%size%<&8><&rb>"
     - narrate "<&5><el@val[|].pad_right[3]><&7>Priority<&co> <&f><el@val[%priority%].pad_right[3]><&7>  Parent<&co> <&f>%parent%"
     - if <def[ownerPlayers].is_empty||true>
       && <def[ownerGroups].is_empty||true> {
       - narrate "<&5><el@val[|].pad_right[3]><&7>Owners<&co> <&c>none"
       }
       else {
       - define ownerList '<def[ownerPlayers].parse[as_player.name].include[<def[ownerGroups].parse[replace[regex:^].with[<&b>]]||>].comma_separated>'
       - define lines '<proc[dRegions_LineWrap].context[Owners, <def[ownerList]>|45]>'
       - narrate "<&5><el@val[|].pad_right[3]><&7><def[lines].get[1].split[, ].get[1]><&co>  <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
       - foreach <def[lines].remove[1]> {
         - narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
         }
       }
     - if <def[memberPlayers].is_empty||true>
       && <def[memberGroups].is_empty||true> {
       - narrate "<&5><el@val[|].pad_right[3]><&7>Members<&co> <&c>none"
       }
       else {
       - define memberList '<def[memberPlayers].parse[as_player.name].include[<def[memberGroups].parse[replace[regex:^].with[<&b>]]||>].comma_separated>'
       - define lines '<proc[dRegions_LineWrap].context[Members, <def[memberList]>|45]>'
       - narrate "<&5><el@val[|].pad_right[3]><&7><def[lines].get[1].split[, ].get[1]><&co>  <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
       - foreach <def[lines].remove[1]> {
         - narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
         }
       }
     - if <def[flags].is_empty> {
       - narrate "<&5><el@val[|].pad_right[3]><&7>Flags<&co> <&c>none"
       }
       else {
       - narrate "<&5><el@val[|].pad_right[3]><&7>Flags<&co>"
       - foreach '<def[flags].alphanumeric>' {
         - define flag '<def[value].split[/].get[1]>'
         - define flagVal '<def[value].after[/]>'
         - define flagValLength '<def[flagVal].length>'
         - define lines '<proc[dRegions_LineWrap].context[%flag%, <def[flagVal]>|45]>'
         - narrate "<&5><el@val[|].pad_right[5]><&e><def[lines].get[1].split[, ].get[1]><&co> <&f><def[lines].get[1].split[, ].remove[1].comma_separated>"
         - foreach <def[lines].remove[1]> {
           - narrate "<&5><el@val[|].pad_right[7]><&f><def[value]>"
           }
         }
       }
     - narrate "<&5>|"
     - inject locally msgsFooter instantly
 
   addowner:
   # /drg addowner [ID] g:group player
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Parse specified owners
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define owners '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
       }
       else {
       - define owners '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
       }
     - if <def[owners].is_empty||true> {
       - run s@dRegions_Msg 'def:<&c>Must specify at least one owner'
       - queue clear
       }
     - foreach %owners% {
       - if <def[value].starts_with[g;]||false> {
         - define group '<def[value].replace[g;]>'
         - define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
         - if <def[groups].contains[%group%]||false> {
           - run s@dRegions_Msg 'def:<&c>Group %group% is already an owner'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.owners.groups:->:%group%' 'id:dRegions_%world%_regions'
         }
         else {
         - if !<def[value].as_player.is[!=].to[null]||false> {
           - foreach next
           }
         - define players '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
         - if <def[players].contains[<def[value].as_player.uuid>]||false> {
           - run s@dRegions_Msg 'def:<&c>Player %value% is already an owner'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.owners.players:->:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
         }
       }
     - if <def[pass].exists||false> {
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> owners updated'
       }
 
   removeowner:
   # /drg removeowner [ID] g:group player
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Parse specified owners
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define owners '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
       }
       else {
       - define owners '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
       }
     - if <def[owners].is_empty||true> {
       - run s@dRegions_Msg 'def:<&c>Must specify at least one owner'
       - queue clear
       }
     - foreach %owners% {
       - if <def[value].starts_with[g;]||false> {
         - define group '<def[value].replace[g;]>'
         - define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
         - if <def[groups].contains[%group%].not||true> {
           - run s@dRegions_Msg 'def:<&c>Group %group% is not an owner'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.owners.groups:<-:%group%' 'id:dRegions_%world%_regions'
         }
         else {
         - if !<def[value].as_player.is[!=].to[null]||false> {
           - foreach next
           }
         - define players '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
         - if <def[players].contains[<def[value].as_player.uuid>].not||true> {
           - run s@dRegions_Msg 'def:<&c>Player %value% is not an owner'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.owners.players:<-:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
         }
       }
     - if <def[pass].exists||false> {
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> owners updated'
       }
       else {
       - run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> owners not updated!'
       }
 
   addmember:
   # /drg addmember [ID] g:group player
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Parse specified members
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define members '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
       }
       else {
       - define members '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
       }
     - if <def[members].is_empty||true> {
       - run s@dRegions_Msg 'def:<&c>Must specify at least one member'
       - queue clear
       }
     - foreach %members% {
       - if <def[value].starts_with[g;]||false> {
         - define group '<def[value].replace[g;]>'
         - define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
         - if <def[groups].contains[%group%]||false> {
           - run s@dRegions_Msg 'def:<&c>Group %group% is already a member'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.members.groups:->:%group%' 'id:dRegions_%world%_regions'
         }
         else {
         - if !<def[value].as_player.is[!=].to[null]||false> {
           - foreach next
           }
         - define players '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
         - if <def[players].contains[<def[value].as_player.uuid>]||false> {
           - run s@dRegions_Msg 'def:<&c>Player %value% is already a member'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.members.players:->:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
         }
       }
     - if <def[pass].exists||false> {
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> members updated'
       }
       else {
       - run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> members not updated!'
       }
 
   removemember:
   # /drg reomvemember [ID] g:group player
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Parse specified members
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define members '<def[args].get[3].to[<def[args].size>].replace[:].with[;]||null>'
       }
       else {
       - define members '<c.args.get[3].to[<c.args.size>].replace[:].with[;]||null>'
       }
     - if <def[members].is_empty||true> {
       - run s@dRegions_Msg 'def:<&c>Must specify at least one member'
       - queue clear
       }
     - foreach %members% {
       - if <def[value].starts_with[g;]||false> {
         - define group '<def[value].replace[g;]>'
         - define groups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
         - if <def[groups].contains[%group%].not||true> {
           - run s@dRegions_Msg 'def:<&c>Group %group% is not a member'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.members.groups:<-:%group%' 'id:dRegions_%world%_regions'
         }
         else {
         - if !<def[value].as_player.is[!=].to[null]||false> {
           - foreach next
           }
         - define players '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
         - if <def[players].contains[<def[value].as_player.uuid>].not||true> {
           - run s@dRegions_Msg 'def:<&c>Player %value% is not a member'
           - foreach next
           }
         - define pass true
         - yaml set 'regions.%name%.members.players:<-:<def[value].as_player.uuid>' 'id:dRegions_%world%_regions'
         }
       }
     - if <def[pass].exists||false> {
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> members updated'
       }
       else {
       - run s@dRegions_Msg 'def:<&6><&o>%name%<&c><&o> members not updated!'
       }
 
   list:
   # /drg list (page#) -r region -w world -p player
 
     - define args '<c.args.remove[1]>'
     # Check the specified player
     - if <def[args].find[-p].is[OR_MORE].than[0]||false> {
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - run s@dRegions_Msg 'def:<&c>You may not list other players regions!'
         - queue clear
         }
       - define player '<def[args].get[<def[args].find[-p].add[1].as_int>].escaped||null>'
       - if !<def[player].as_player.is[!=].to[null]||false> {
         - run s@dRegions_Msg 'def:<&c>Invalid player specfied!'
         - queue clear
         }
       - define filterPlayer ''
       - define args '<def[args].remove[<def[args].find[-p].add[1].as_int>].exclude[-p]||li@>'
       }
       else {
       - if <context.server.not> {
         - define player '<player.name>'
         }
         else {
         - define player 'null'
         }
       }
 
     # Check the specified world
     - if <def[args].find[-w].is[OR_MORE].than[0]||false> {
       - define world '<def[args].get[<def[args].find[-w].add[1].as_int>].as_world.name.to_lowercase.escaped||null>'
       - if <def[world].is[==].to[null]||true> {
         - run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
         - queue clear
         }
       - define filterWorld ''
       - define args '<def[args].remove[<def[args].find[-w].add[1].as_int>].exclude[-w]||li@>'
       }
       else {
       - if <context.server.not> {
         - define world '<player.world.name.to_lowercase>'
         }
         else {
         - define world 'null'
         }
       }
 
     # Does the player want to list the regions where he stands?
     - if <def[args].find[-h].is[OR_MORE].than[0]||false> {
       - define filterHere ''
       - define args '<def[args].remove[<def[args].find[-h]>]||li@>'
       }
 
     # Do we want to show results for ALL worlds?
     - if <def[args].find[-a].is[OR_MORE].than[0]||false> {
       - define worlds '<server.list_worlds.parse[name.to_lowercase]>'
       - define getAll ''
       - define args '<def[args].remove[<def[args].find[-a]>]||li@>'
       }
 
     # Check the specified region name
     - if <def[args].find[-r].is[OR_MORE].than[0]||false> {
       - define region '<def[args].get[<def[args].find[-r].add[1].as_int>].escaped||null>'
       - if <def[region].is[!=].to[null]||true> {
         - define exists '<proc[dRegions_RegionExists].context[<def[region]>|<def[world]>]>'
         - if <def[exists].is[==].to[orphan]> {
           - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
           - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
           - queue clear
           }
           else if <def[exists].not> {
           - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
           - queue clear
           }
         - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
           - if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
             - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
             - queue clear
             }
           }
         }
         else {
         - run s@dRegions_Msg 'def:<&c>You must specify a valid region ID!'
         - queue clear
         }
       - define filterRegion ''
       - define args '<def[args].remove[<def[args].find[-r].add[1].as_int>].exclude[-r]||li@>'
       }
 
     # OK, we've validated all the user input, let's get the regions and apply filters
     - define regions li@
     - if <def[filterHere].exists> {
       - define standingIn '<player.location.cuboids.parse[notable_name].filter[split[_].get[1].is[==].to[dRegions]].parse[after[dregions_%world%_]].replace[li@].replace[|].with[,]>'
       - define worldRegions '<proc[dRegions_HighestPriority].context[%world%|%standingIn%]||li@>'
       - if <def[worldRegions].is_empty||true> {
         - define worldRegions 'li@__global__'
         }
       - inject locally filterRegionList
       }
       else if <def[getAll].exists> {
       - foreach %worlds% {
         - define world %value%
         - define worldRegions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
         - inject locally filterRegionList
         }
       }
       else {
       - define worldRegions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__].alphanumeric||li@>'
       - inject locally filterRegionList
       }
 
     # Display the list
     - define page '<def[args].get[1].replace[-].escaped||1>'
     - if <def[page].is[MATCHES].to[number].not> {
       - define page '1'
       }
     - define pages '<def[regions].size.div[14].round_up||1>'
     - if <def[page].is[MORE].than[%pages%]> {
       - define page '%pages%'
       }
     - define highNumber '<def[page].mul[14].as_int>'
     - define lowNumber '<def[highNumber].sub[13].as_int>'
     - define msgsHeaderTitle '<&e>Region List   <el@val[<&7><&o>Page <&f><&o>%page% <&7><&o>of %pages%].pad_left[30]>'
     - inject locally msgsHeader instantly
     - foreach <def[regions].get[%lowNumber%].to[%highNumber%]||li@> {
       - define color '<t[<def[value].split[/].get[3].is[==].to[owner]>]:&6||<t[<def[value].split[/].get[3].is[==].to[member]>]:&e||&f>>'
       - narrate "<&5>|<&sp><&7><el@val[<el@val[<def[lowNumber].add[<def[loop_index].sub[1]>].as_int>.].pad_left[4].with[<&sp>]>].pad_right[5].with[<&sp>]> <%color%><def[value].split[/].get[2]>"
       }
     - narrate "<&5>|"
     - inject locally msgsFooter instantly
 
   flag:
   # /drg flag [ID] [flag] [value] -g group -w world
 
     - define args '<c.args.remove[1]>'
 
     # Check the specified world
     - if <def[args].find[-w].is[OR_MORE].than[0]||false> {
       - define world '<def[args].get[<def[args].find[-w].add[1].as_int>].as_world.name.escaped.to_lowercase||null>'
       - if <def[world].is[==].to[null]||true> {
         - run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
         - queue clear
         }
       - define args '<def[args].remove[<def[args].find_all[-w].parse[add[1].as_int]>].exclude[-w]||li@>'
       }
       else {
       - if <context.server.not> {
         - define world '<player.world.name.to_lowercase>'
         }
         else {
         - define world 'null'
         }
       }
 
     # Check the specified group
     - if <def[args].find[-g].is[OR_MORE].than[0]||false> {
       - define group '<def[args].get[<def[args].find[-g].add[1].as_int>].escaped.to_lowercase||null>'
       - if !<el@val[members|nonmembers|owners|nonowners|all].as_list.contains[%group%]||false> {
         - run s@dRegions_Msg 'def:<&c><def[group].unescaped> is an invalid group!'
         - queue clear
         }
       - define args '<def[args].remove[<def[args].find_all[-g].parse[add[1].as_int]>].exclude[-g]||li@>'
       }
 
     # Check the specified region name
     - define region '<def[args].get[1].escaped.to_lowercase||null>'
     - if <def[region].is[!=].to[null]||true> {
       - define exists '<proc[dRegions_RegionExists].context[<def[region]>|<def[world]>]>'
       - if <def[exists].is[==].to[orphan]> {
         - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
         - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
         - queue clear
         }
         else if <def[exists].not> {
         - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
         - queue clear
         }
       - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
         - if <proc[dRegions_IsOwner].context[<def[region]>|<def[world]>|<player>].not> {
           - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
           - queue clear
           }
         }
       }
       else {
       - run s@dRegions_Msg 'def:<&c>You must specify a valid region ID!'
       - queue clear
       }
 
     # Check the specified flag name
     - define flag '<def[args].get[2].escaped.to_lowercase||null>'
     - if <def[flag].is[!=].to[null]||true> {
       - define flags '<server.list_scripts.filter[starts_with[s@dRegions_Flag_]].parse[name.split[_].get[3]]||li@>'
       - if !<def[flags].contains[%flag%]||false> {
         - run s@dRegions_Msg 'def:<&c>You must specify a valid region flag!'
         - queue clear
         }
       }
       else {
       - run s@dRegions_Msg 'def:<&c>You must specify a valid region flag!'
       - queue clear
       }
 
     # By this point, we know the flag is being set or cleared, so let's clear the flag
     # cache for this region, any child regions, and any overlapping regions including __global__
     - run s@dRegions p:clearCache delay:1t 'def:%region%|%world%|%flag%'
 
     # Check the specified flag value and set or clear it.
     - define flagValue '<def[args].get[3].to[<def[args].size>].space_separated.escaped||null>'
     - if <def[flagValue].is[!=].to[null]||true> {
       - define type '<s@dRegions_Flag_%flag%.yaml_key[flag_type]>'
       - if <def[type].is[==].to[location]> {
         - if <def[flagValue].is[==].to[here]||true> {
           - define flagValue '<player.location.simple>'
           }
         }
       - define typeMatch '<proc[dRegion_FlagTypeMatch].context[%flagValue%|%flag%]>'
       - if !<def[TypeMatch]> {
         - define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
         - foreach <def[lines]> {
           - run s@dRegions_Msg 'def:<&c><def[value]>'
           }
         - queue clear
         }
       - if <def[type].starts_with[state]||false>
         && <def[flagValue].is[==].to[none]||false> {
         - inject s@dRegions_Flag_%flag% p:command_handler
         - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
         - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
         - yaml 'savefile:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
         - run s@dRegions_Msg 'def:<&c>Cleared %flag% flag for region %region%'
         - queue clear
         }
       - inject s@dRegions_Flag_%flag% p:command_handler
       - if <s@dRegions_Flag_%flag%.yaml_key[flag_takeGroup]||false> {
         - if <def[group].exists> {
           - yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>/%group%' 'id:dRegions_%world%_regions'
           }
           else {
           - yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>' 'id:dRegions_%world%_regions'
           }
         }
         else {
         - yaml set 'regions.%region%.flags.%flag%:<def[flagValue].unescaped>' 'id:dRegions_%world%_regions'
         }
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/cache.yml' 'id:dRegions_%world%_cache'
       - define string "<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%"
       - define lines '<proc[dRegions_LineWrap].context[<def[string]>|45]>'
       - foreach <def[lines]> {
         - run s@dRegions_Msg 'def:<&f><&o><def[value].unescaped>'
         }
       }
       else {
       - inject s@dRegions_Flag_%flag% p:command_handler
       - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&c>Cleared %flag% flag for region %region%'
       - queue clear
       }
 
   setpriority:
   # /drg setpriority [ID] [#]
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Verify specified priority
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define priority '<def[args].get[3].escaped||null>'
       }
       else {
       - define priority '<c.args.get[3].escaped||null>'
       }
     - if <def[priority].is[matches].to[number].not||true> {
       - run s@dRegions_Msg 'def:<&c>Must specify a numeric value for priority'
       - queue clear
       }
     # Update region
     - yaml set 'regions.%name%.priority:%priority%' 'id:dRegions_%world%_regions'
     - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
     - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> set priority to <&f><&o>%priority%'
 
   setparent:
   # /drg setparent [ID] [parent]
     - inject locally prerun instantly
     # Check if child region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Check if parent region exists
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define parent '<def[args].get[3].escaped||null>'
       }
       else {
       - define parent '<c.args.get[3].escaped||null>'
       }
     - if %parent% == null {
       - define parent <yaml[dRegions_%world%_regions].read[regions.%name%.parent]||null>
       - if %parent% != null {
         - yaml set 'regions.%parent%.children:<-:%name%' 'id:dRegions_%world%_regions'
         }
       - yaml set 'regions.%name%.parent:!' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg 'def:<&7><&o>Unset parent for <&f><&o>%name%'
       - queue clear
       }
     # Check if parent region exists
     - define exists '<proc[dRegions_RegionExists].context[%parent%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Check if player owns parent
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%parent%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Update the region
     - yaml set 'regions.%name%.parent:%parent%' 'id:dRegions_%world%_regions'
     - if <yaml[dRegions_%world%_regions].read[regions.%parent%.children]||li@> contains %name% {
       - yaml set 'regions.%parent%.children:<-:%name%' 'id:dRegions_%world%_regions'
       }
       else {
       - yaml set 'regions.%parent%.children:->:%name%' 'id:dRegions_%world%_regions'
       }
     - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
     - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> set parent to <&f><&o>%parent%'
 
   teleport:
     - narrate "Stub"
 
   remove:
   # /drg remove [ID] -w world
     - inject locally prerun instantly
     # Check if region exists
     - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
     - if <def[exists].is[==].to[orphan]> {
       - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
       - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
       - queue clear
       }
       else if <def[exists].not> {
       - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
       - queue clear
       }
     # Don't remove the __global__ region
     - if <def[name].is[==].to[__global__]> {
       - run s@dRegions_Msg 'def:<&c>You can not remove the __global__ region!'
       - queue clear
       }
     # Check if is owner
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
         - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
         - queue clear
         }
       }
     # Remove region from ancestry
     # This should be done smarterer now since regions know both children and parents.
     - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__]||li@>'
     - foreach %regions% {
       - if <yaml[dRegions_%world%_regions].read[regions.%value%.parent]||null> == %name% {
         - yaml set 'regions.%value%.parent:<-:%name%' 'id:dRegions_%world%_regions'
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%value%.children]||li@> contains %name% {
         - yaml set 'regions.%value%.children:<-:%name%' 'id:dRegions_%world%_regions'
         }
       }
     # Remove the region
     - yaml set 'regions.%name%:!' 'id:dRegions_%world%_regions'
     - note remove 'as:dregions_%world%_%name%'
     - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
     - run s@dRegions_Msg 'def:<&f><&o>%name%<&7><&o> has been removed from <&f><&o>%world%'
 
 #
 #  END dRegions Command Arguments
 #--------------------------------------
 #
 #  dRegions Command Utilities
 #
 # Just some commonly used code blocks
 #
   prerun:
   # Block of checks run before /most/ commands
     - if !<player.has_permission[dRegions.%command%]||<player.is_op||false>> {
       - inject locally help
       - queue clear
       }
     - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
       - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name.to_lowercase||null>'
       - if <def[world].is[==].to[null]||true> {
         - run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
         - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
         - queue clear
         }
       - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
       - define name '<def[args].get[2].escaped.to_lowercase||null>'
       }
       else {
       - define world '<player.world.name.to_lowercase>'
       }
     - if <li@define|redefine|claim.contains[%command%]> {
       - define wandType '<player.flag[dWEWand_Type]||cuboid>'
       - if <li@cuboid|extender.contains[%wandType%].not||true> {
         - run s@dRegions_Msg 'def:<&c>You must select a cuboid type region!'
         - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
         - queue clear
         }
       - define pos1 '<player.flag[dWEWand].get[1].as_location||null>'
       - define pos2 '<player.flag[dWEWand].get[2].as_location||null>'
       - if <def[pos1].is[==].to[null]>
         || <def[pos2].is[==].to[null]> {
         - run s@dRegions_Msg 'def:<&c>No region selected!'
         - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
         - queue clear
         }
       - if <def[pos1].world.name.is[!=].to[%world%]>
         || <def[pos2].world.name.is[!=].to[%world%]> {
         - run s@dRegions_Msg 'def:<&c>Selected region not within specified world!'
         - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
         - queue clear
         }
       - define selectedCuboid '<cu@%pos1%|%pos2%>'
       }
     - define name '<def[name]||<c.args.get[2].escaped.to_lowercase||null>>'
     - if '<def[name].is[==].to[null]||true>' {
       - if <li@info|select.contains[%command%]> {
         - define dRegions '<player.location.cuboids.parse[notable_name].filter[split[_].get[1].is[==].to[dRegions]].parse[after[dregions_%world%_]].replace[li@].replace[|].with[,]>'
         - define orderedRegions '<proc[dRegions_HighestPriority].context[%world%|%dRegions%]>'
         - if <def[orderedRegions].is_empty||true> {
           - define name '__global__'
           }
           else {
           - define name '<def[orderedRegions].get[1]>'
           - if <def[orderedRegions].size.is[MORE].than[1]> {
             - run s@dRegions_Msg 'def:<&c><&o>There are multiple regions at this location!'
             - run s@dRegions_Msg 'def:<&7><&o>Getting highest priority region info.'
             }
           }
         }
         else {
         - run s@dRegions_Msg 'def:<&c>You must specify a region ID!'
         - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
         - queue stop
         }
       }
     - if '<def[name].matches[^[a-z0-9-_]+$].not>' {
       - run s@dRegions_Msg 'def:<&c>Region ID may only contain letters, numbers,'
       - run s@dRegions_Msg 'def:<&c>hyphen, and underscore!'
       - run s@dRegions_Msg 'def:<script.yaml_key[commandArgs.%command%.usage]>'
       - queue stop
       }
 #    - inject s@dRegions_Commands p:selection_Size instantly
 #    - define oldSize '%size%'
 
 
   filterRegionList:
   # Used in /drg list to apply various filters
     - if <def[filterRegion].exists||false> {
       - define filteredRegions 'li@'
       - foreach %worldRegions% {
         - define worldRegion '%value%'
         - if <yaml[dRegions_%world%_regions].read[regions.%worldRegion%.parent].is[==].to[<def[region]>]||false> {
           - define filteredRegions '<def[filteredRegions].include[%worldRegion%]||<def[filteredRegions]>>'
           }
         }
       }
     - if <def[filteredRegions].exists> {
       - define worldRegions '<def[filteredRegions]>'
       }
     - foreach %worldRegions% {
       - define worldRegion '%value%'
       - if <proc[dRegions_IsOwner].context[<def[worldRegion]>|<def[world]>|<def[player].as_player>]||false> {
         - define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/owner]||<def[regions]>>'
         }
         else if <proc[dRegions_IsMember].context[<def[worldRegion]>|<def[world]>|<def[player].as_player>]||false> {
         - define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/member]||<def[regions]>>'
         }
         else if <def[filterPlayer].exists.not||true> {
         - define regions '<def[regions].include[<def[world]>/<def[worldRegion]>/nonmember]||<def[regions]>>'
         }
       }
 
   regionInfo:
   # Build the data set for region info
     - define type '<yaml[dRegions_%world%_regions].read[regions.%name%.type]||null>'
     - if <def[type].is[==].to[cuboid]||false> {
       - define POS1 '<yaml[dRegions_%world%_regions].read[regions.%name%.min]||null>'
       - define POS2 '<yaml[dRegions_%world%_regions].read[regions.%name%.max]||null>'
       - inject s@dWE_Commands p:selection_Size instantly
       }
       else if <def[type].is[==].to[global]||false> {
       - define POS1 '0,0,0,%world%'
       - define POS2 '0,0,0,%world%'
       - define size 'infinite'
       }
       else {
       - run s@dRegions_Msg 'def:<&c>This region is misconfigured!'
       - run s@dRegions_Msg 'def:<&c>Notify an Admin!'
       - queue clear
       }
     - define priority '<yaml[dRegions_%world%_regions].read[regions.%name%.priority]||0>'
     - define parent '<yaml[dRegions_%world%_regions].read[regions.%name%.parent]||<&c>none>'
     - define ownerGroups '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.groups]||li@>'
     - define ownerPlayers '<yaml[dRegions_%world%_regions].read[regions.%name%.owners.players]||li@>'
     - define memberGroups '<yaml[dRegions_%world%_regions].read[regions.%name%.members.groups]||li@>'
     - define memberPlayers '<yaml[dRegions_%world%_regions].read[regions.%name%.members.players]||li@>'
     - define flagList '<yaml[dRegions_%world%_regions].list_keys[regions.%name%.flags]||li@>'
     - define flags 'li@'
     - foreach %flagList% {
       - define flags '<def[flags].include[%value%/<yaml[dRegions_%world%_regions].read[regions.%name%.flags.%value%].as_list.comma_separated||null>]||%flags%>'
       }
 
 #
 #  END dRegions dRegions Command Utilities
 #--------------------------------------
 #
 #  dRegions Command Messages
 #
 # Some messages used by commands. Should probably move to s@dRegions_Msg
 #
   msgsHeader:
     - narrate "<&5>|----------------------------------------|"
     - narrate "<&5>|<&sp><&sp><&sp><&6>dRegions   <&7><def[msgsHeaderTitle]||>"
     - narrate "<&5>|<&f>"
 
   msgsFooter:
     - define anthony "text<&co>'<&7>|Anthony|',clickEvent<&co><&chr[007B]>action<&co>open_url,value<&co>'http<&co>//mineconomy.org'<&chr[007D]>,hoverEvent<&co><&chr[007B]>action<&co>show_item,value<&co>'<&chr[007B]><i@AnthonyBanner.json><&chr[007D]>'<&chr[007D]>"
     - define spacer "text<&co>'  '"
     - define prefix "text<&co>'<&5>|  <&f>Authors<&co>  '"
     - if <player.is_player||false> {
       - execute as_server "tellraw <player.name> <&chr[007B]>text<&co>'',extra<&co>[<&chr[007B]>%prefix%<&chr[007D]>,<&chr[007B]>%anthony%<&chr[007D]>]<&chr[007D]>"
       }
       else {
       - announce to_console "<&5>|  <&f>Authors<&co>    <&7>|Anthony|"
       }
     - narrate "<&5>|-----------<&d>S<&5>-<&d>c<&5>-<&d>r<&5>-<&d>o<&5>-<&d>l<&5>-<&d>l<&5>---<&d>U<&5>-<&d>p<&5>-------------|"
 
   msgsHelpAdmin:
     # Filter the list of commands this player can use
     - define commands '<script.list_keys[commandArgs].alphanumeric.to_lowercase||li@>'
     - foreach %commands% {
       - if !<player.has_permission[dregions.%value%]||<player.is_op||<c.server||false>>> {
         - define commands '<def[commands].exclude[%value%]>'
         }
         else {
         - foreach next
         }
       }
 
     # Display the list
     - define page '<def[arg].replace[-].escaped||1>'
     - if <def[page].is[MATCHES].to[number].not> {
       - define page '1'
       }
     - define pages '<def[commands].size.div[5].round_up||1>'
     - if <def[page].is[MORE].than[%pages%]> {
       - define page '%pages%'
       }
     - define highNumber '<def[page].mul[5].as_int>'
     - define lowNumber '<def[highNumber].sub[4].as_int>'
     - define msgsHeaderTitle '<&e>Admin Help   <el@val[<&7><&o>Page <&f><&o>%page% <&7><&o>of %pages%].pad_left[30]>'
     - inject locally msgsHeader instantly
     - foreach <def[commands].get[%lowNumber%].to[%highNumber%]||li@> {
       - narrate "<&5>|<&sp><&sp><&f><def[value].to_titlecase><&co>"
       - narrate "<&5>|<&sp><&sp><&sp><&sp><&7><script.yaml_key[commandArgs.%value%.usage]||No usage info available!>"
       }
     - narrate "<&5>|"
 
   msgsHelpUser:
     - define msgsHeaderTitle 'User Help'
     - inject locally msgsHeader instantly
     - define par1 "dRegions is an advanced region management and world protection system written with the Denizen Scripting Engine."
     - define par2 "Heavily inspired by WorldGuard, the goal is to have an extremely efficient events system supporting an exhaustive set of region flags and configuration options."
     - define par3 "dRegions offers an intuitive command interface and provides thorough TAB completion."
     - define strings "<el@val[%par1%|%par2%|%par3%].as_list>"
     - foreach <def[strings]> {
       - define string "<&f><&sp><def[value]>"
       - define lines '<proc[dRegions_LineWrap].context[<def[string]>|44]>'
       - foreach <def[lines]> {
         - narrate "<&5>|<&f><&sp><&sp><def[value].unescaped>"
         }
       - narrate "<&5>|"
       }
 
 #
 #  END dRegions Command Messages
 #--------------------------------------
 #
 #  I want to test moving all command arguments to their own command script so I
 # can have the dregions command and the alias of these scripts run the same
 # code. I'd like to add the flexibility for folks to type the full command
 #    /dregions select
 # or the shorter alias
 #    /.sel
 # and use the same code base, tab completion and all
 #
 # -----
 #  dRegions Select Command
 #
 # Select a region by ID and optionally world
 #
 #dRegions_Command_Sel:
 #  type: command
 #  debug: false
 #  name: select
 #  description: Select a region by ID and optionally world
 #  usage: /.sel
 #  aliases:
 #  - .sel
 #  allowed help:
 #  - determine true
 #  tab complete:
 #    - define args 'li@help|reload|define|redefine|claim|select|info|addowner|removeowner|addmember|removemember|list|flag|setpriority|setparent|teleport|remove'
 #    - define arg '<c.args.get[1]||null>'
 #    - if <def[arg].is[==].to[null]>
 #      || !<def[args].contains[%arg%]> {
 #      - inject locally tab_arg_1
 #      }
 #      else inject locally tab_%arg%
 #    - determine '<def[result]||li@>'
 
 #  script:
 #  # We only want to run it if the user issues the alias /.sel command
 #    - if <c.alias.is[!=].to[.sel]||true> queue clear
 
 #    - define command 'select'
 #    - define args 'li@help|reload|select|define|redefine|remove|addowner|addmember|setparent|setpriority'
 #    - if !<def[args].contains[%command%]> inject locally help instantly
 #      else inject locally %command% instantly
 
 #  sel:
 #  # /drg select [ID]
 #    - inject locally prerun instantly
 #    # Check if region exists
 #    - define exists '<proc[dRegions_RegionExists].context[%name%|%world%]>'
 #    - if <def[exists].is[==].to[orphan]> {
 #      - run s@dRegions_Msg 'def:<&c>There is an orphaned region by this name!'
 #      - run s@dRegions_Msg 'def:<&c>Please notify an admin!'
 #      - queue clear
 #      }
 #      else if <def[exists].not> {
 #      - run s@dRegions_Msg 'def:<&c>There is no region by this name!'
 #      - queue clear
 #      }
 #    # Check if is owner
 #    - if !<player.has_permission[dregions.admin]||false> {
 #      - if <proc[dRegions_IsOwner].context[%name%|%world%|<player>].not> {
 #        - run s@dRegions_Msg 'def:<&c>You are not an owner of this region!'
 #        - queue clear
 #        }
 #      }
 #    - define min '<yaml[dRegions_%world%_regions].read[regions.%name%.min].as_location.simple||null>'
 #    - define max '<yaml[dRegions_%world%_regions].read[regions.%name%.max].as_location.simple||null>'
 #    - flag <player> 'dWEWand_Type:cuboid'
 #    - flag <player> dWEWand:!
 #    - flag <player> dWEWand:|:%min%|%max%
 #    - run s@dRegions_Msg 'def:<&7><&o>Selected <&f><&o>%name%'
 
 #  prerun:
 #  # Block of checks run before /most/ commands
 #    - if !<player.has_permission[dRegions.%command%]||<player.is_op||false>> {
 #      - inject locally help
 #      - queue clear
 #      }
 #    - if <c.args.find[-w].is[OR_MORE].than[0]||false> {
 #      - define world '<c.args.get[<c.args.find[-w].add[1].as_int>].escaped.as_world.name||null>'
 #      - if <def[world].is[==].to[null]||true> {
 #        - run s@dRegions_Msg 'def:<&c>Invalid world specfied!'
 #        - queue clear
 #        }
 #      - define args '<c.args.remove[<c.args.find[-w].add[1].as_int>].exclude[-w]>'
 #      - define name '<def[args].get[2].escaped||null>'
 #      }
 #      else define world '<player.world.name>'
 #    - if <li@define|redefine|claim.contains[%command%]> {
 #      - define wandType '<player.flag[dWEWand_Type]||cuboid>'
 #      - if <li@cuboid|extender.contains[%wandType%].not||true> {
 #        - run s@dRegions_Msg 'def:<&c>You must select a cuboid type region!'
 #        - queue clear
 #        }
 #      - define pos1 '<player.flag[dWEWand].get[1].as_location||null>'
 #      - define pos2 '<player.flag[dWEWand].get[2].as_location||null>'
 #      - if <def[pos1].is[==].to[null]>
 #        || <def[pos2].is[==].to[null]> {
 #        - run s@dRegions_Msg 'def:<&c>No region selected!'
 #        - queue clear
 #        }
 #      - if <def[pos1].world.name.is[!=].to[%world%]>
 #        || <def[pos2].world.name.is[!=].to[%world%]> {
 #        - run s@dRegions_Msg 'def:<&c>Selected region not within specified world!'
 #        - queue clear
 #        }
 #      - define selectedCuboid '<cu@%pos1%|%pos2%>'
 #      }
 #    - define name '<def[name]||<c.args.get[2].escaped||null>>'
 #    - if <def[name].is[==].to[null]||true> {
 #      - run s@dRegions_Msg 'def:<&c>You must specify a name!'
 #      - queue stop
 #      }
 
 #
 #  END dRegions Command Script Basics
 #--------------------------------------
 #
 #  dRegions Command TAB Completion
 #
 # Each of these subscripts handles TAB completion for the positional argument.
 #
 #
 #--------------------------------------
 #
 #  dRegions Other Utilities
 #
 # Other Utility functions used throughout dRegions
 #
 ##dRegions_HasPerm:
 ##  I have to think about this more...
 ##  # A procedure script to check if a player has any of the required permissions for a command
 ##  # <proc[dRegions_HasPerm].context[command|player|region]>
 ##  type: procedure
 ##  definition: command|player|region
 ##  constants:
 ##    define:
 ##    - admin
 ##    - define
 ##    redefine:
 ##    - admin
 ##    - redefine
 ##    - redefine.own.*
 ##    - redefine.own.%region%
 ##    - redefine.member.*
 ##    - redefine.member.%region%
 ##
 ##  script:
 ##    - if '<def[region].exsits.not||true>' determine false
 ##    - define perms <script.constant[%command%]>
 
 
 dRegions_RegionSort:
   type: procedure
   definitions: region1|region2
   speed: 0
   debug: false
 
   script:
     - define region1pri '<def[region1].split[/].get[1]>'
     - define region2pri '<def[region2].split[/].get[1]>'
     - if %region1pri% > %region2pri% {
       - determine -1
       }
     - if %region1pri% < %region2pri% {
       - determine 1
       }
     - if %region1pri% == %region2pri% {
       - determine 0
       }
 
 dRegions_IsOwner:
   # A procedure script to check if a player is a region owner
   # <proc[dRegions_IsOwner].context[region|world|player]>
   type: procedure
   definitions: region|world|player
   speed: 0
   debug: false
 
   script:
     - define playerUUID '<def[player].uuid>'
     - if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> {
       - determine 'true'
       }
     - define playerGroups '<def[player].groups||li@>'
     - if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
       - determine 'true'
       }
     # Regions inherit members and owners.
     - while <el@a.is[==].to[a]> {
       - define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
       - if %region% == null {
         - while stop
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.players].contains[%playerUUID%]||false> {
         - determine 'true'
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%region%.owners.groups].contains_any[%playerGroups%]||false> {
         - determine 'true'
         }
       }
     - determine 'false'
 
 
 dRegions_IsMember:
   # A procedure script to check if a player is a region member
   # <proc[dRegions_IsMember].context[region|world|player]>
   type: procedure
   definitions: region|world|player
   speed: 0
   debug: false
 
   script:
     - define playerUUID '<def[player].uuid>'
     - if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> {
       - determine 'true'
       }
     - define playerGroups '<def[player].groups||li@>'
     - if <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
       - determine 'true'
       }
     # Regions inherit members and owners.
     - while <el@a.is[==].to[a]> {
       - define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
       - if %region% == null {
         - while stop
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%region%.members.players].contains[%playerUUID%]||false> {
         - determine 'true'
         }
       - if <yaml[dRegions_%world%_regions].read[regions.%region%.members.groups].contains_any[%playerGroups%]||false> {
         - determine 'true'
         }
       }
     - determine 'false'
 
 
 dRegions_RegionExists:
   # A procedure script to check if a region exists
   # <proc[dRegions_RegionExists].context[region|world]>
   type: procedure
   definitions: region|world
   speed: 0
   debug: false
 
   script:
     - if %region% == '__global__' {
       - determine true
       }
 #    - define notables '<cu@dregions_%world%_%region%.is[!=].to[null].not||true>'
     - define notables '<server.list_notables[cuboids].contains[cu@dregions_%world%_%region%].not||true>'
     - define regions '<yaml[dRegions_%world%_regions].contains[regions.%region%].not||true>'
     - if %notables% && %regions% {
       - determine false
       }
       else if %notables% || %regions% {
       - determine orphan
       }
       else {
       - determine true
       }
 
 
 dRegions_HighestPriority:
   # Filter a list of regions by priority in descending order
   # <proc[dRegions_HighestPriority].context[world|region1,...]>
   type: procedure
   definitions: world|regions
   speed: 0
   debug: false
 
   script:
     - define regions '<def[regions].split[,]||li@>'
     - define regionPri 'li@'
     - foreach %regions% {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - determine '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
 
 
 dRegions_RegionOverlaps:
   # A procedure script to check if a region overlaps other (un)owned regions
   # <proc[dRegions_RegionOverlaps].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|%name%|%world%|<player>]>
   # NOTE: If for some reason the selected cuboid overlaps an unowned region that is a lower priority than
   # a region that the player does own and is completely within, it will not be considered as an overlap!
   #  - But why would there be a lower priority region inside a higher priority region... that's not
   #    how priorities should be used!
   type: procedure
   definitions: selectedCuboid|world|player
   speed: 0
   debug: false
 
   script:
     - define selectedCuboid '<def[selectedCuboid].split[/].as_cuboid>'
     - define regions '<yaml[dRegions_%world%_regions].list_keys[regions].exclude[__global__]||li@>'
     - define notables '<def[regions].parse[replace[regex:^].with[cu@dregions_%world%_]].filter[as_cuboid.is[!=].to[null]]||li@>'
     - define overlaps '<def[notables].filter[intersects[<def[selectedCuboid]>]].parse[replace[cu@dregions_%world%_]]||li@>'
     - define orderedRegions '<proc[dRegions_HighestPriority].context[%world%|<def[overlaps].replace[li@].replace[|].with[,]>]||li@>'
     - foreach <def[orderedRegions]> {
       - if <proc[dRegions_IsOwner].context[%value%|%world%|<player>].not> {
         - determine true
         }
 #      - if <proc[dRegions_CuboidIsWithinCuboid].context[<def[selectedCuboid].replace[cu@].replace[|].with[/]>|<def[value].replace[regex:^].with[cu@dregions_%world%_].as_cuboid.full.replace[cu@].replace[|].with[/]>]> {
       - if <def[selectedCuboid].is_within[<def[value].replace[regex:^].with[cu@dregions_%world%_].as_cuboid>]> {
         - determine false
         }
       }
     # By this point, we've determined that the player either owns all the regions at this cuboid location
     # or that the new cuboid is completely within a region that he does own.
     - determine false
 
 
 dRegions_PlayerMatchRegionGroup:
   # Check if a player matches a region flag group setting.
   # <proc[dRegions_PlayerMatchRegionGroup].context[group|region|world|player]>
   type: procedure
   definitions: group|region|world|player
   speed: 0
   debug: false
 
   script:
     - inject locally %group%
 
   all:
     - determine 'true'
 
   members:
     - determine '<proc[dRegions_isMember].context[%region%|%world%|%player%]>'
 
   nonmembers:
     - if <proc[dRegions_isOwner].context[%region%|%world%|%player%]> {
       - determine 'false'
       }
     - if <proc[dRegions_isMember].context[%region%|%world%|%player%]> {
       - determine 'false'
       }
     - determine 'true'
 
   owners:
     - determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%]>'
 
   nonowners:
     - determine '<proc[dRegions_isOwner].context[%region%|%world%|%player%].not>'
 
 
 
 dRegions_CuboidIsWithinCuboid:
   # Checks if one cuboid is completely within another cuboid
   # <proc[dRegions_CuboidIsWithinCuboid].context[inner|outer]>
   type: procedure
   definitions: inner|outer
   speed: 0
   debug: false
 
   script:
     - define innerCuboid '<def[inner].split[/].as_cuboid>'
     - define outerCuboid '<def[outer].split[/].as_cuboid>'
 
     - if <def[innerCuboid].min.x.is[OR_MORE].than[<def[outerCuboid].min.x>]>
       && <def[innerCuboid].min.y.is[OR_MORE].than[<def[outerCuboid].min.y>]>
       && <def[innerCuboid].min.z.is[OR_MORE].than[<def[outerCuboid].min.z>]>
       && <def[innerCuboid].max.x.is[OR_LESS].than[<def[outerCuboid].max.x>]>
       && <def[innerCuboid].max.y.is[OR_LESS].than[<def[outerCuboid].max.y>]>
       && <def[innerCuboid].max.z.is[OR_LESS].than[<def[outerCuboid].max.z>]> {
       - determine true
       }
       else {
       - determine false
       }
 
 
 dRegions_GetInheritedFlag:
   # Get a region flag value. Start at current child and ascend through parents
   # until a value is set or you reach the origin ancestor
   # <proc[dRegions_GetInheritedFlag].context[world|region|flag]>
   type: procedure
   definitions: world|region|flag
   speed: 0
   debug: false
 
   script:
     - define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||null>'
     - while <def[return].is[==].to[null]> {
       - define region '<yaml[dRegions_%world%_regions].read[regions.%region%.parent]||null>'
       - if %region% == null {
         - while stop
         }
       - define return '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%]||null>'
       }
     - determine '%return%'
 
 
 dRegions_CanUse_Block:
 # Procedure script to determine if a player can use a block at a location.
 # Will work for any block that can be interacted with (chests, doors, levers, etc.)
 # <proc[dRegions_CanUse_Block].context[player|location]>
   type: procedure
   speed: 0
   debug: false
   definitions: player|location
 
   script:
     - define world '<def[location].world.name>'
     - define target '<def[location].material.bukkit_enum>'
     - define FlagScript '<s@dRegions_Map_Interactions.yaml_key[block.%target%]||s@dRegions_Map_Interactions>'
     - define flag '<def[FlagScript].yaml_key[flag_name]||null>'
     - if %flag% == null determine false
     - if <def[player].has_permission[dregions.admin]||<def[player].is_op>> determine true
     - define flag-targetList '<def[FlagScript].yaml_key[flag_targetList]||null>'
     - if <def[location].cuboids.is_empty||true> {
       - inject locally check-global
       - determine 'true'
       - queue clear
       }
     - define regionPri 'li@'
     - foreach <def[location].cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
       - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
       }
     - define orderedRegions '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]]>'
     - inject locally check-region
     - determine 'true'
 
   check-global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
     - if %flagObj% == null {
       - define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
       }
     - if %flagObj% != none {
       - if <def[flagObj].split[/].get[1]> == allow {
         - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
 #          - inject %FlagScript% p:event-cleanup
           - determine false
           }
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
         - if ( %targetList% != li@null ) && ( %targetList% != li@all ) && ( %targetList% !contains %target% ) {
 #          - inject %FlagScript% p:event-cleanup
           - determine false
           }
         }
         else {
         - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
           - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
           - if ( %targetList% == li@null ) || ( %targetList% == li@all ) || ( %targetList% contains %target% ) {
 #            - inject %FlagScript% p:event-cleanup
             - determine false
             }
           }
         }
       }
 
   check-region:
     - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
       - define region '<def[orderedRegions].get[1]>'
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
       }
       else {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       }
     - if %flagObj% == null {
       - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
       }
     - if %flagObj% != none {
       - if <def[flagObj].split[/].get[1]> == allow {
         - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
 #          - inject %FlagScript% p:event-cleanup
           - determine false
           }
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
         - if ( %targetList% != li@null ) && ( %targetList% != li@all ) && ( %targetList% !contains %target% ) {
 #          - inject %FlagScript% p:event-cleanup
           - determine false
           }
         }
         else {
         - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
           - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
           - if ( %targetList% == li@null ) || ( %targetList% == li@all ) || ( %targetList% contains %target% ) {
 #            - inject %FlagScript% p:event-cleanup
             - determine false
             }
           }
         }
       }
 
 
 dRegions_getRelativeLocation:
   # A procedure script to get a location relative to another location.
   # Specify the direction as   n s e w u d
   # <proc[dRegions_getRelativeLocation].context[location|direction|distance]>
   type: procedure
   definitions: l|d|n
   speed: 0
   debug: false
 
   n_math: sub
   n_coord: '0,0,<def[n]>'
   s_math: add
   s_coord: '0,0,<def[n]>'
   w_math: sub
   w_coord: '<def[n]>,0,0'
   e_math: add
   e_coord: '<def[n]>,0,0'
   d_math: sub
   d_coord: '0,<def[n]>,0'
   u_math: add
   u_coord: '0,<def[n]>,0'
 
   script:
     - define math '<script.yaml_key[%d%_math]>'
     - define coord '<script.yaml_key[%d%_coord]>'
     - determine "<def[l].as_location.%math%[%coord%]>"
 
 
 dRegions_LineWrap:
   # Turn a long string into a list of smaller strings
   type: procedure
   definitions: string|targetLen
   speed: 0
   debug: false
 
   script:
     - define stringLen '<def[string].length>'
     - if <def[stringLen].is[MORE].than[%targetLen%]> {
       - define lines 'li@'
       - while <def[stringLen].is[MORE].than[0]> {
         - define low '<def[increment].add[1].as_int||1>'
         - define hi '<def[increment].add[<def[targetLen].add[1]>].as_int||%targetLen%>'
         - define pass '<def[string].substring[%low%,%hi%]>'
         - if <def[pass].length.is[==].to[%stringLen%]> {
           - define lines '<def[lines].include[%pass%]||<def[lines]>>'
           - while stop
           }
           else {
           - define brake '<def[pass].last_index_of[ ]>'
           - define increment '<def[increment].add[%brake%]||%brake%>'
           - define passtrim '<def[pass].substring[1,<t[<def[brake].is[MORE].than[0]>]:%brake%||<def[pass].length>>]>'
           - define lines '<def[lines].include[%passtrim%]||<def[lines]>>'
           - define stringLen '<def[stringLen].sub[%brake%]>'
           }
         - if <def[loop_index].is[MORE].than[10]> {
           - while stop
           }
         }
       - determine '<def[lines].as_list>'
       }
       else {
       - determine '<def[string].as_list>'
       }
 
 
 ################################################################################
 #
 #  FlagTypeMatch Procedure script
 #
 #    Used to check that the player specified value matches the type required
 #   by the flag.
 #
 #    Use this to compare 2 values. Check if they are one of NUMBER, DECIMAL,
 #   LOCATION, BOOLEAN, STATE, GROUP, LIST or any other STRING.
 #
 #   usage:
 #     - define YourValue "Some string"
 #     - define Type "<s@dRegions_Flag_%flag%.yaml_key[flag_type]||null>"
 #     - define TypeMatch '<proc[dRegion_FlagTypeMatch].context[%YourValue%|%flag%]>'
 #     - if <def[TypeMatch]> {
 #       - narrate "%YourValue% matches %type%."
 #       }
 #       else {
 #       - narrate "%YourValue% is a %YourValueType% not a %type%"
 #       }
 #
 dRegion_FlagTypeMatch:
   type: procedure
   speed: 0
   debug: false
   definitions: YourValue|Flag
 
   script:
 
     - define Type "<s@dRegions_Flag_%Flag%.yaml_key[flag_type]||null>"
     - if <def[Type].is[==].to[number]> {
       - if <def[YourValue].is[MATCHES].to[number]> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[decimal]> {
       - if <def[YourValue].is[MATCHES].to[decimal]> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[boolean]> {
       - if <def[YourValue].is[MATCHES].to[boolean]> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[location]> {
       - if <def[YourValue].as_location.world.is[!=].to[null]||false> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].starts_with[state]> {
       - if <el@val[allow|deny|none].as_list.contains[%YourValue%]||false> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[group]> {
       - if <el@val[members|nonmembers|owners|nonowners|all].as_list.contains[%YourValue%]||false> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[list]> {
       - if '<def[YourValue].split[ ].get[1].contains_any_text[-a|-r]||false>' {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[custom]> {
       - if <s@dRegions_Flag_%flag%.yaml_key[flag_type_customVal].as_list.contains[%YourValue%]||false> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - if <def[Type].is[==].to[string]> {
       - if <def[YourValue].is[!=].to[null]||false> {
         - determine 'true'
         }
         else {
         - determine 'false'
         }
       }
     - determine 'false'
 
 #
 #  END other utilities
 #--------------------------------------
 #
 #  dRegions author banner items
 #
 # Banner items representing the authors
 #
 dRegions_Author_Anthony:
   type: item
   speed: 0
   debug: false
   material: i@human_skull
   display name: "<&f>             |Anthony|"
   lore:
   - <&7>  Owner<&co> <&e>M<&6>ine<&e>C<&6>onomy <&e>N<&6>etwork
   - <&5>-------------------------
   - <&7>
   - <&7>  I`ve been playing minecraft
   - <&7> and running a server since
   - <&7> 2010. I have fun and share
   - <&7> what I do.
   - <&7>
   - <&9>           Click To Visit
 #
 #  END dRegions author banner items
 #--------------------------------------
 #
 #  dRegions Interaction Mapping
 #
 # Mapping what to do when interacting with blocks and items
 #
 dRegions_Map_Interactions:
   type: yaml data
   debug: false
 
   # Used as a fallback for non-existent interaction mappings
   event:
     - queue clear
   event-global:
     - queue clear
 
   block:
 # Containers
     chest: s@dRegions_Flag_Chest-Access
     ender_chest: s@dRegions_Flag_Chest-Access
     locked_chest: s@dRegions_Flag_Chest-Access
     trapped_chest: s@dRegions_Flag_Chest-Access
     dispenser: s@dRegions_Flag_Chest-Access
     hopper: s@dRegions_Flag_Chest-Access
     dropper: s@dRegions_Flag_Chest-Access
 # Doors
     trap_door: s@dRegions_Flag_Door-Access
     iron_trapdoor: s@dRegions_Flag_Door-Access
     wooden_door: s@dRegions_Flag_Door-Access
     iron_door_block: s@dRegions_Flag_Door-Access
     spruce_door: s@dRegions_Flag_Door-Access
     birch_door: s@dRegions_Flag_Door-Access
     jungle_door: s@dRegions_Flag_Door-Access
     dark_oak_door: s@dRegions_Flag_Door-Access
     acacia_door: s@dRegions_Flag_Door-Access
     fence_gate: s@dRegions_Flag_Door-Access
     spruce_fence_gate: s@dRegions_Flag_Door-Access
     birch_fence_gate: s@dRegions_Flag_Door-Access
     jungle_fence_gate: s@dRegions_Flag_Door-Access
     dark_oak_fence_gate: s@dRegions_Flag_Door-Access
     acacia_fence_gate: s@dRegions_Flag_Door-Access
 # Switches
     lever: s@dRegions_Flag_Use-Switches
     wood_button: s@dRegions_Flag_Use-Switches
     stone_button: s@dRegions_Flag_Use-Switches
     wood_plate: s@dRegions_Flag_Use-Switches
     stone_plate: s@dRegions_Flag_Use-Switches
     iron_plate: s@dRegions_Flag_Use-Switches
     gold_plate: s@dRegions_Flag_Use-Switches
 # Utility Blocks
     workbench: s@dRegions_Flag_Use-Utilities
     furnace: s@dRegions_Flag_Use-Utilities
     burning_furnace: s@dRegions_Flag_Use-Utilities
     brewing_stand: s@dRegions_Flag_Use-Utilities
     enchantment_table: s@dRegions_Flag_Use-Utilities
     anvil: s@dRegions_Flag_Use-Utilities
     beacon: s@dRegions_Flag_Use-Utilities
     jukebox: s@dRegions_Flag_Use-Utilities
     note_block: s@dRegions_Flag_Use-Utilities
 #    cauldron: useUtility
 #    tnt: useUtility
 # Other blocks that change when clicked regardless of item in hand
     flower_pot: s@dRegions_Flag_Build
     cake_block: s@dRegions_Flag_Build
     diode_block_on: s@dRegions_Flag_Build
     diode_block_off: s@dRegions_Flag_Build
     redstone_comparator_off: s@dRegions_Flag_Build
     redstone_comparator_on: s@dRegions_Flag_Build
 
   block_withItem:
 #    jukebox: s@dRegions_Flag_Use-Utilities/air/gold_record|green_record|record_3|record_4|record_5|record_6|record_7|record_8|record_9|record_10|record_11|record_12
     cauldron: s@dRegions_Flag_Use-Utilities/bucket|water_bucket|glass_bottle
     tnt: s@dRegions_Flag_Use-Utilities/flint_and_steel
     activator_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
     detector_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
     powered_rail: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
     rails: s@dRegions_Flag_Vehicle-Place/minecart|storage_minecart|powered_minecart|explosive_minecart|hopper_minecart|command_minecart
     stationary_water: s@dRegions_Flag_Vehicle-Place/boat
     water: s@dRegions_Flag_Vehicle-Place/boat
     mob_spawner: s@dRegions_Flag_Build/monster_egg
 
   item:
     ink_sac:
     gold_record: jukebox
     glass_bottle: cauldron
     flint_and_steel: tnt
 
 #
 #  END dRegions Interaction Mapping
 #--------------------------------------
 
 
 
 
 ################################################################################
 #                                                                              #
 # Configuration Files                                                          #
 #                                                                              #
 #   These are the default config files. They will be used to build the default #
 # configuration and data storage files.                                        #
 #                                                                              #
 #______________________________________________________________________________#
 #                                                                              #
 #______________________________DO_NOT_EDIT_THIS_DATA___________________________#
 #______________________________________________________________________________#
 
 
 dRegions_Configurations:
   type: yaml data
 
   config:
     version: 0.27
     regions:
       enable: true
       invincibility-removes-mobs: false
       wand: dWE_Wand
       ownerOnDefine: false
       claim:
         max-volume: 0
         only-inside-existing-regions: true
         max-region-count-per-player:
           default: 7
     spread:
       water: true
       water-list: []
       lava: true
       lava-list: []
       mycel: true
       grass: true
       mushroom: true
       vines: true
     physics:
       gravel: true
       sand: true
     portal:
       create: true
       entity-enter: true
       player-enter: true
     fire:
       ender_crystal: true
       explosion: true
       fireball: true
       flint_and_steel: true
       lava: true
       spread: true
       spread-list: []
       destroyBlocks: true
       destroyBlocks-list: []
     entity:
       changeBlocks: true
       changeBlocks-list: []
       explode: true
       explode-list: []
     entity-break-item_frame: true
     entity-break-painting: true
     blockform:
       ice: true
       snow: true
       snow-list: []
     blockfade:
       ice: true
       snow: true
     lightning-strike: true
     lightning-strike-list: []
     trample-crops:
       player: true
       entity: true
     leaf-decay: true
     player-damage: true
     player-damage-list: []
 #    auto-invincible: false
 #    protection:
 #      item-durability: true
 #      remove-infinite-stacks: false
 #      disable-xp-orb-drops: false
 #      disable-obsidian-generators: true
 #    weather:
 #      prevent-lightning-strike-blocks: []
 #      disable-lightning-strike-fire: false
 #      disable-thunderstorm: false
 #      disable-weather: false
 #      disable-pig-zombification: false
 #      disable-powered-creepers: false
 #      always-raining: false
 #      always-thundering: false
 
   regions:
     __global__:
       type: global
       priority: 0
       flags: []
       owners: []
       members: []
 
   inventories:
     info:
       - This is the inventory save file.
       - DO NOT EDIT!
     example:
       region:
         entry:
           kit:
             equip: []
             inv: []
           players:
             player:
               equip: []
               inv: []
         exit:
           players:
             player:
               equip: []
               inv: []
 
   cache:
     boolean: []
     state-withTarget: []
     info:
       - This is the cache file. We use this file to cache individual specific events so that we can reduce the number of flag lookups later on.
       - Expect it to grow to a considerable size!
 
 
 #
 
 ################################################################################
 #
 #                                d R e g i o n s
 #
 #                                 Flag Modules
 #
 #   Authors: |Anthony|
 #   Version: 0.2
 #   dScript Version: 0.9.6-DEV_b140
 #
 #
 #
 #--- About this script
 #
 #  Adding new flags /can/ be as easy as making a new module!
 #
 #
 #
 ################################################################################
 
 
 dRegions_Flag_Entry:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entry<&4>]"
   lore:
   - <&5>Who can enter a region
   event_hook: regionEnter
   event_priority: 0
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define player <player>
     - define region '<def[orderedRegions].get[1]>'
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entry]>'
       - if %flagObj% != null {
         - inject s@dRegions_Flags_Processors p:state-withGroup
         }
       }
     - run locally entered delay:1t player:<player> def:%world%|%region%|<def[orderedRegions].escaped>
 
   event-global:
     - define player <player>
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entry]>'
       - if %flagObj% != null {
         - inject s@dRegions_Flags_Processors p:state-withGroup-Global
         }
       }
     - run locally entered-global delay:1t player:<player> def:%world%|__global__
 
   entered:
     - ^define world '%1%'
     - ^define region '%2%'
     - ^define orderedRegions '<def[3].unescaped>'
     - ^define player '<player>'
     - ^inject s@dRegions_Flag_Notify-Enter p:event
     - ^inject s@dRegions_Flag_Greeting p:event
     - ^inject s@dRegions_Flag_Inventory p:event-enter
     - ^inject s@dRegions_Flag_Gamemode p:event-enter
     - ^inject s@dRegions_Flag_Heal-Amount p:event
     - ^inject s@dRegions_Flag_Feed-Amount p:event
 
   entered-global:
     - ^define world '%1%'
     - ^define region '%2%'
     - ^define player '<player>'
     - ^inject s@dRegions_Flag_Notify-Enter p:event-global
     - ^inject s@dRegions_Flag_Greeting p:event-global
     - ^inject s@dRegions_Flag_Inventory p:event-enter
     - ^inject s@dRegions_Flag_Gamemode p:event-enter
     - ^inject s@dRegions_Flag_Heal-Amount p:event-global
     - ^inject s@dRegions_Flag_Feed-Amount p:event-global
 
   event-cleanup:
     - if <player.is_inside_vehicle||false> {
       - run locally vehicle 'def:<player.get_vehicle>|<c.from>' delay:1t
       }
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to enter this region'
       }
 
   vehicle:
     - ^if <player.has_flag[dRegions_regionKick]> {
       - queue clear
       }
       else {
       - flag <player> dRegions_regionKick d:5t
       }
     - ^mount cancel <player>|%1%
     - ^teleport '<player>' '<def[2].above>'
     - ^wait 20t
     - ^adjust %1% 'velocity:l@0,0,0,<def[1].world>'
     - ^teleport %1% '<t[<def[1].is_living>]:<player.location>||<def[2].above>>'
 
 
 dRegions_Flag_Exit:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Exit<&4>]"
   lore:
   - <&5>Who can exit a region
   event_hook: regionExit
   event_priority: 0
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define player <player>
     - define region '<def[orderedRegions].get[1]>'
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|exit]>'
       - if %flagObj% != null {
         - inject s@dRegions_Flags_Processors p:state-withGroup
         }
       }
     - run locally exited delay:1t player:<player> def:%world%|%region%|<def[orderedRegions].escaped>
 
   event-global:
     - define player <player>
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|exit]>'
       - if %flagObj% != null {
         - inject s@dRegions_Flags_Processors p:state-withGroup-Global
         }
       }
     - run locally exited-global delay:1t player:<player> def:%world%|__global__
 
   exited:
     - ^define world '%1%'
     - ^define region '%2%'
     - ^define orderedRegions '<def[3].unescaped>'
     - ^define player '<player>'
     - ^inject s@dRegions_Flag_Notify-Exit p:event
     - ^inject s@dRegions_Flag_Farewell p:event
     - ^inject s@dRegions_Flag_Inventory p:event-exit
     - ^inject s@dRegions_Flag_Gamemode p:event-exit
 
   exited-global:
     - ^define world '%1%'
     - ^define region '%2%'
     - ^define player '<player>'
     - ^inject s@dRegions_Flag_Notify-Exit p:event-global
     - ^inject s@dRegions_Flag_Farewell p:event-global
     - ^inject s@dRegions_Flag_Inventory p:event-Exit
     - ^inject s@dRegions_Flag_Gamemode p:event-Exit
 
 
   event-cleanup:
     - if <player.is_inside_vehicle||false> {
       - define vehicle '<player.get_vehicle>'
       - run locally vehicle 'def:%vehicle%|<c.from>' delay:1t
       }
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to exit this region'
       }
 
   vehicle:
     - ^if <player.has_flag[dRegions_regionKick]> {
       - queue clear
       }
       else {
       - flag <player> dRegions_regionKick d:5t
       }
     - ^mount cancel <player>|%1%
     - ^teleport '<player>' '<def[2].above>'
     - ^wait 20t
     - ^adjust %1% 'velocity:l@0,0,0,<def[1].world>'
     - ^teleport %1% '<t[<def[1].is_living>]:<player.location>||<def[2].above>>'
 
 
 dRegions_Flag_Notify-Enter:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Notify-Enter<&4>]"
   lore:
   - <&5>Send notification to marked players
   event_hook: regionEnter
   event_priority: 5
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: false
   flag_help: Boolean flag controlling whether notifications are sent for entering this region. Set to true or false. Defaults to false.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
   # We only notify for the highest priority region, but we inherit the flag value from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|notify-enter]>'
     - if %flagVal% == true {
       - foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
         - run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> entered %region% in %world%'
         }
       }
 
   event-global:
   # We only notify for the highest priority region, but we inherit the flag value from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|notify-enter]>'
     - if %flagVal% = true {
       - foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
         - run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> entered the global region in %world%'
         }
       }
 
 
 dRegions_Flag_Notify-Exit:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Notify-Exit<&4>]"
   lore:
   - <&5>Send notification to marked players
   event_hook: regionExit
   event_priority: 5
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: false
   flag_help: Boolean flag controlling whether notifications are sent for exiting this region. Set to true or false. Defaults to false.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
   # We only notify for the highest priority region, but we inherit the flag value from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|notify-exit]>'
     - if %flagVal% == true {
       - foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
         - run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> left %region% in %world%'
         }
       }
 
   event-global:
   # We only notify for the highest priority region, but we inherit the flag value from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|notify-exit]>'
     - if %flagVal% = true {
       - foreach <server.list_online_players.filter[has_permission[dregions.notify]].include[<server.list_online_ops>].deduplicate> {
         - run player:%value% s@dRegions_Msg 'def:<&5><&o><def[player].name> left the global region in %world%'
         }
       }
 
 
 dRegions_Flag_Greeting:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Greeting<&4>]"
   lore:
   - <&5>Message on enter region
   event_hook: regionEnter
   event_priority: 10
   flag_type: string
   flag_takeGroup: false
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
   # We should only get a message from the highest priority region, but let's inherit from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|greeting]>'
     - if %flagVal% != null {
 #      - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
       - narrate "<parse:%flagVal%>"
       - adjust <player> 'action_bar:<parse:%flagVal%>'
       }
 
   event-global:
   # We should only get a message from the highest priority region, but let's inherit from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|greeting]>'
     - if %flagVal% != null {
 #      - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
       - narrate "<parse:%flagVal%>"
       - adjust <player> 'action_bar:<parse:%flagVal%>'
       }
 
 
 dRegions_Flag_Farewell:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Farewell<&4>]"
   lore:
   - <&5>Message on exit region
   event_hook: regionExit
   event_priority: 10
   flag_type: string
   flag_takeGroup: false
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
   # We should only get a message from the highest priority region, but let's inherit from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|farewell]>'
     - if %flagVal% != null {
 #      - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
       - narrate "<parse:%flagVal%>"
       - adjust <player> 'action_bar:<parse:%flagVal%>'
       }
 
   event-global:
   # We should only get a message from the highest priority region, but let's inherit from parents.
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|farewell]>'
     - if %flagVal% != null {
 #      - narrate "<def[flagVal].replace[regex:&([0-9a-fA-Fk-oK-OrR])].with[<&r.before[r]>$1]>
       - narrate "<parse:%flagVal%>"
       - adjust <player> 'action_bar:<parse:%flagVal%>'
       }
 
 
 dRegions_Flag_Inventory:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Inventory<&4>]"
   lore:
   - <&5>Save inventory before going into a region
   event_hook: regionToggle
   event_priority: 10
   flag_type: custom
   flag_type_customVal: unique|kit
   flag_help: Inventory flag can be set to unique or kit. Unique inventories start empty. Kit inventories use your current inventory.
   flag_takeGroup: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if <def[flagValue].is[==].to[kit]> {
       - yaml set 'inventories.regions.%region%.entry.kit.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
       - yaml set 'inventories.regions.%region%.entry.kit.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
       - yaml set 'inventories.regions.%region%.exit.players:|:' 'id:dRegions_%world%_inventories'
       }
     - if <def[flagValue].is[==].to[unique]> {
       - yaml set 'inventories.regions.%region%.entry.players:|:' 'id:dRegions_%world%_inventories'
       - yaml set 'inventories.regions.%region%.exit.players:|:' 'id:dRegions_%world%_inventories'
       }
     - if <def[flagValue].is[==].to[null]> {
       - yaml set 'inventories.regions.%region%:!' 'id:dRegions_%world%_inventories'
       }
     - yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
 
   event-enter:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|inventory]>'
     - if %flagObj% != null {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
         - inject locally <def[flagObj].split[/].get[1]>-enter
         }
       }
 
   event-exit:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|inventory]>'
     - if %flagObj% != null {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
         - inject locally <def[flagObj].split[/].get[1]>-exit
         }
       }
 
   kit-enter:
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
     - yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
     - inventory clear
     - inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.kit.inv]||li@>'
     - define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.kit.equip]||li@>'
     - equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
     - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
 
   kit-exit:
     - define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.equip]||li@>'
     - inventory clear
     - inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.inv]||li@>'
     - equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>:!' 'id:dRegions_%world%_inventories'
     - yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
     - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
 
   unique-enter:
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
     - yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
     - inventory clear
     - inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<player.uuid>.inv]||li@>'
     - define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.entry.players.<player.uuid>.equip]||li@>'
     - equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
     - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
 
   unique-exit:
     - yaml set 'inventories.regions.%region%.entry.players.<player.uuid>.equip:<player.equipment>' 'id:dRegions_%world%_inventories'
     - yaml set 'inventories.regions.%region%.entry.players.<player.uuid>.inv:<player.inventory.list_contents>' 'id:dRegions_%world%_inventories'
     - define equipment '<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.equip]||li@>'
     - inventory clear
     - inventory set 'd:<player.inventory>' 'o:<yaml[dRegions_%world%_inventories].read[inventories.regions.%region%.exit.players.<player.uuid>.inv]||li@>'
     - equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
     - yaml set 'inventories.regions.%region%.exit.players.<player.uuid>:!' 'id:dRegions_%world%_inventories'
     - yaml 'savefile:dRegions/worlds/%world%/inventories.yml' 'id:dRegions_%world%_inventories'
     - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your inventory has been updated.'
 
 
 dRegions_Flag_Gamemode:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Gamemode<&4>]"
   lore:
   - <&5>Change gamemode inside a region
   event_hook: regionToggle
   event_priority: 20
   flag_type: custom
   flag_type_customVal: creative|survival|adventure
   flag_help: Gamemode flag can be set to creative, survival, or adventure
   flag_takeGroup: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-enter:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|gamemode]>'
     - if %flagObj% != null {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
         - define gm '<def[flagObj].split[/].get[1]>'
         - if %gm% != <player.gamemode> {
           - flag <player> 'dRegions_%world%_%region%_PreviousGamemode:<player.gamemode>'
           - adjust <player> 'gamemode:%gm%'
           - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your gamemode has been updated.'
           }
         }
       }
 
   event-exit:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|gamemode]>'
     - if %flagObj% != null {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%region%|%world%|<player>]> {
         - if <player.flag[dRegions_%world%_%region%_PreviousGamemode]||null> != <player.gamemode> {
           - adjust <player> 'gamemode:<player.flag[dRegions_%world%_%region%_PreviousGamemode]||survival>'
           - run s@dRegions_Msg delay:1t 'def:<&7><&o>Your gamemode has been updated.'
           }
         - flag <player> 'dRegions_%world%_%region%_PreviousGamemode:!'
         }
       }
 
 
 dRegions_Flag_Build:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Build<&4>]"
   lore:
   - <&5>Override default build perms
   event_hook: build
   event_priority: 0
   flag_type: state-withGroup
   flag_name: Build
   flag_help: By default, all members and owners can build in their regions. Setting this flag can over ride that behavior. Can be set to allow, deny, or none and accepts the -g group switch.
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
   # Build is handled differently than the other flags. It checks only the HIGHEST
   # priority region. It does inherit owners, members, and flags from parent regions.
     - define region '<def[orderedRegions].get[1]>'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|build]>'
     - if %flagObj% == null {
       - define flagObj 'deny/nonmembers'
       }
     - define player <player>
     - inject s@dRegions_Flags_Processors p:state-withGroup
 
   event-global:
   # Build is handled differently than the other flags. It checks only the HIGHEST
   # priority region. It does inherit owners, members, and flags from parent regions.
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|build]>'
     - if %flagObj% != null {
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup-global
       }
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You do not have permission to build in this region'
       }
 
 
 dRegions_Flag_Vehicle-Place:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Vehicle-Place<&4>]"
   lore:
   - <&5>Who can place vehicles
   event_hook: placeVehicle
   event_priority: 5
   flag_type: state-withGroup
   flag_help: Control who can place vehicles in a region. Takes the -g group switch.
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t 'def:<c.item.material.name.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not place %1%s here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vehicle-place]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vehicle-place]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Vehicle-Destroy:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Vehicle-Destroy<&4>]"
   lore:
   - <&5>Who can destroy vehicles
   event_hook: destroyVehicle
   event_priority: 10
   flag_type: state-withGroup
   flag_help: Control who can destroy vehicles in a region. Takes the -g group switch.
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t 'def:<c.vehicle.entity_type.to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break %1%s here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vehicle-destroy]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vehicle-destroy]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Send-Chat:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Send-Chat<&4>]"
   lore:
   - <&5>Who can chat
   event_hook: sendChat
   event_priority: 10
   flag_type: state-withGroup
   flag_help: Control who can send chat in a region. Takes the -g group switch.
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: true
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not chat here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define region '<def[orderedRegions].get[1]>'
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|send-chat]>'
         - if %flagObj% != null {
           - define player <player>
           - inject s@dRegions_Flags_Processors p:state-withGroup
           - foreach stop
           }
         }
       }
 
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|send-chat]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Hunger:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Hunger<&4>]"
   lore:
   - <&5>Who can get hungry
   event_hook: changeFood
   event_priority: 10
   flag_type: state-withGroup
   flag_help: Control whether players will loose hunger in this region. Takes the -g group switch.
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: false
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|hunger]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup
         - foreach stop
         }
       }
 
   event-global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hunger]>'
     - if %flagObj% != null {
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup-global
       }
 
 
 dRegions_Flag_Mob-Target:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Target<&4>]"
   lore:
   - <&5>Can mobs target players
   event_hook: ENTITY_Target_Player
   event_priority: 0
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether mobs will be able to target players in this region. Defaults to allow all. Use mob-target flag to specify mob types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<c.target.flag[dRegions.cache.%world%.%value%.mob-target.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
           - queue clear
           }
         - flag %player% dRegions.rateLimit.mob-target.%target%:false d:10s
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-target]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
         - flag %player% dRegions.cache.%world%.%value%.mob-target.%target%:none
         }
       }
     - if %flagObj% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-targetlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
       - flag %player% dRegions.cache.%world%.%thisRegion%.mob-target.%target%:true
       }
       else {
       - flag %player% dRegions.rateLimit.mob-target.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-target]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-targetlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag %player% dRegions.rateLimit.mob-target.%target%:true d:5s
       - flag %player% dRegions.cache.%world%.__global__.mob-target.%target%:true
       }
       else {
       - flag %player% dRegions.rateLimit.mob-target.%target%:true d:5s
       - flag %player% dRegions.cache.%world%.__global__.mob-target.%target%:none
       }
 
   event-cleanup:
     - remove <c.projectile||li@>
     - attack %attacker% target:cancel
     - flag %player% dRegions.rateLimit.mob-target.%target%:false d:5s
     - flag %player% dRegions.cache.%world%.%thisRegion%.mob-target.%target%:false
 
 
 dRegions_Flag_Mob-TargetList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Target<&4>]"
   lore:
   - <&5>List of mobs used by mob-targeting flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Mob-Target
   flag_takeGroup: false
   flag_help: List flag used with mob-targeting flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Mob-Damage:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Damage<&4>]"
   lore:
   - <&5>Can mobs damage players
   event_hook: ENTITY_Damage_Player
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether mobs will be able to damage players in this region. Defaults to allow all. Use mob-damagelist flag to specify mob types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<c.entity.flag[dRegions.cache.%world%.%value%.mob-damage.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
           - queue clear
           }
         - flag %player% dRegions.rateLimit.mob-damage.%target%:false d:10s
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-damage]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
         - flag %player% dRegions.cache.%world%.%value%.mob-damage.%target%:none
         }
       }
     - if %flagObj% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-damagelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
       - flag %player% dRegions.cache.%world%.%thisRegion%.mob-damage.%target%:true
       }
       else {
       - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-damage]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-damagelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
       - flag %player% dRegions.cache.%world%.__global__.mob-damage.%target%:true
       }
       else {
       - flag %player% dRegions.rateLimit.mob-damage.%target%:true d:10s
       - flag %player% dRegions.cache.%world%.__global__.mob-damage.%target%:none
       }
 
   event-cleanup:
     - remove <c.projectile||li@>
     - attack %attacker% target:cancel
     - flag %player% dRegions.rateLimit.mob-damage.%target%:false d:10s
     - flag %player% dRegions.cache.%world%.%thisRegion%.mob-damage.%target%:false
 
 
 dRegions_Flag_Mob-Damagelist:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-DamageList<&4>]"
   lore:
   - <&5>List of mobs used by mob-damage flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Mob-Damage
   flag_takeGroup: false
   flag_help: List flag used with mob-damage flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Mob-Spawn:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Spawn<&4>]"
   lore:
   - <&5>Can mobs Spawn
   event_hook: ENTITY_Spawn
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether mobs will be able to spawn in this region. Defaults to allow all. Use mob-spawnlist flag to specify mob types.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.mob-spawn.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-spawn]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-spawnlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-spawn]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-spawnlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.mob-spawn.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.mob-spawn.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.mob-spawn.%target%:false' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Mob-SpawnList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Spawnlist<&4>]"
   lore:
   - <&5>List of mobs used by mob-spawn flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Mob-Spawn
   flag_takeGroup: false
   flag_help: List flag used with mob-spawn flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_EVE:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>EVE<&4>]"
   lore:
   - <&5>Can mobs be targeted
   event_hook: ENTITY_Target_ENTITY
   event_priority: 20
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether mobs can be targeted for attack by other mobs in this region. Defaults to allow. Use eve-moblist flag to specify mob types.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
 #  event:
 #    - foreach %orderedRegions% {
 #      - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|eve]>'
 #      - define region '%value%'
 #      - if %flagVal% != null {
 #        - foreach stop
 #        }
 #      }
 #    - if %flagVal% != null {
 #      - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|eve-moblist].replace[, ].with[|].as_list>'
 #      - define target '%dtarget%'
 #      - inject s@dRegions_Flags_Processors p:state-withTarget
 #      }
 
 #  event-global:
 #    - define orderedRegions 'li@__global__'
 #    - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
 #    - if %flagVal% != null {
 #      - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
 #      - define target '%dtarget%'
 #      - inject s@dRegions_Flags_Processors p:state-withTarget
 #      }
 
 #  event-cleanup:
 #    - remove <c.projectile||li@>
 #    - attack %attacker% target:cancel
 
   event:
     - define target '%dtarget%'
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.eve.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - run locally wander delay:1t def:%attacker%
         - remove <c.projectile||li@>
         - attack %attacker% target:cancel
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|eve]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.eve.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|eve-moblist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.eve.%target%:true' 'id:dRegions_%world%_cache'
       }
 
 #  event-global:
 #    - define target '%dtarget%'
 #    - define region '__global__'
 #    - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
 #    - if %flagVal% != null {
 #      - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
 #      - inject s@dRegions_Flags_Processors p:state-withTarget
 #      }
 #    - yaml set 'cache.state-withTarget.__global__.eve.%target%:true' 'id:dRegions_%world%_cache'
 
   event-global:
     - define target '%dtarget%'
     - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.eve.%target%]||null>'
     - if %cache% == false {
       - remove <c.projectile||li@>
       - attack %attacker% target:cancel
       - run locally wander delay:1t def:%attacker%
       - determine cancelled
       }
     - if %cache% == null {
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve]>'
       - if %flagVal% != null {
         - define region '__global__'
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|eve-moblist].replace[, ].with[|].as_list>'
         - inject s@dRegions_Flags_Processors p:state-withTarget
         - yaml set 'cache.state-withTarget.__global__.eve.%target%:true' 'id:dRegions_%world%_cache'
         }
         else {
         - yaml set 'cache.state-withTarget.__global__.eve.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
 
   event-cleanup:
     - remove <c.projectile||li@>
     - attack %attacker% target:cancel
     - run locally wander delay:1t def:%attacker%
     - yaml set 'cache.state-withTarget.%region%.eve.%target%:false' 'id:dRegions_%world%_cache'
 
   wander:
     - ^if !<def[1].is_spawned||false> queue clear
     - ^adjust %1% toggle_ai:false
     - ^walk %1% <def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location.standing_on>].vertical.is[less].than[3]].filter[distance[<def[1].location>].horizontal.is[more].than[4]].random.add[0,1,0]>
     - ^wait 10s
     - ^if !<def[1].is_spawned||false> queue clear
     - ^adjust %1% toggle_ai:true
 
 
 dRegions_Flag_EVE-Moblist:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>EVE-Moblist<&4>]"
   lore:
   - <&5>List of mobs used by eve flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_EVE
   flag_takeGroup: false
   flag_help: List flag used with eve flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Mob-Attack:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Attack<&4>]"
   lore:
   - <&5>Can mobs attack other mobs
   event_hook: ENTITY_Target_ENTITY
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether mobs can attack other mobs in this region. Defaults to allow. Use mob-attack-moblist flag to specify mob types.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define target '%atarget%'
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.mob-attack.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - define flagVal 'null'
           - foreach stop
           }
         - run locally wander delay:1t def:%attacker%
         - remove <c.projectile||li@>
         - attack %attacker% target:cancel
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mob-attack]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|mob-attack-moblist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define target '%atarget%'
     - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.__global__.mob-attack.%target%]||null>'
     - if %cache% == false {
       - remove <c.projectile||li@>
       - attack %attacker% target:cancel
       - run locally wander delay:1t def:%attacker%
       - determine cancelled
       }
     - if %cache% == null {
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-attack]>'
       - if %flagVal% != null {
         - define region '__global__'
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mob-attack-moblist].replace[, ].with[|].as_list>'
         - inject s@dRegions_Flags_Processors p:state-withTarget
         - yaml set 'cache.state-withTarget.__global__.mob-attack.%target%:true' 'id:dRegions_%world%_cache'
         }
         else {
         - yaml set 'cache.state-withTarget.__global__.mob-attack.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
 
   event-cleanup:
     - remove <c.projectile||li@>
     - attack %attacker% target:cancel
     - run locally wander delay:1t def:%attacker%
     - yaml set 'cache.state-withTarget.%region%.mob-attack.%target%:false' 'id:dRegions_%world%_cache'
 
   wander:
     - ^if !<def[1].is_spawned||false> queue clear
     - ^adjust %1% toggle_ai:false
     - ^walk %1% <def[1].location.find.surface_blocks.within[10].filter[distance[<def[1].location.standing_on>].vertical.is[less].than[3]].filter[distance[<def[1].location>].horizontal.is[more].than[4]].random.add[0,1,0]>
     - ^wait 10s
     - ^if !<def[1].is_spawned||false> queue clear
     - ^adjust %1% toggle_ai:true
 
 
 dRegions_Flag_Mob-Attack-Moblist:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mob-Attack-Moblist<&4>]"
   lore:
   - <&5>List of mobs used by mob-attack flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Mob-Attack
   flag_takeGroup: false
   flag_help: List flag used with mob-attack flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_PVE:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>PVE<&4>]"
   lore:
   - <&5>Can players damage mobs
   event_hook: PLAYER_Damage_Entity
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether players will be able to damage mobs in this region. Defaults to allow all. Use pve-moblist flag to specify mob types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.pve.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
           - queue clear
           }
         - flag <player> dRegions.rateLimit.pve.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pve]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.pve.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|pve-moblist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.pve.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pve]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pve-moblist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.pve.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.pve.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.pve.%target%:none
       }
 
   event-cleanup:
     - remove <c.projectile||li@>
     - flag <player> dRegions.rateLimit.pve.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.pve.%target%:false
     - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not attack %1%s here!'
       }
 
 
 dRegions_Flag_PVE-Moblist:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>PVE-Moblist<&4>]"
   lore:
   - <&5>List of mobs used by pve flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_PVE
   flag_takeGroup: false
   flag_help: List flag used with pve flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of mobs.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Npc-Interact:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>NPC Interact<&4>]"
   lore:
   - <&5>Can players interact with NPCs
   event_hook: npc-interact
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether players will be able to interact with NPCs in this region. Defaults to allow. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define region '%value%'
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|npc-interact]>'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup
         }
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|npc-interact]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
   event-cleanup:
     - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not interact with NPCs here!'
       }
 
 
 dRegions_Flag_Entity-Interact:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity Interact<&4>]"
   lore:
   - <&5>Can players interact with entities
   event_hook: entity-interact
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether players will be able to interact with entities in this region. Defaults to allow all. Use entity-interactlist flag to specify entity types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.entity-interact.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
           - queue clear
           }
         - flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-interact]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.entity-interact.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-interactlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.entity-interact.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-interact]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-interactlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.entity-interact.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.entity-interact.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.entity-interact.%target%:none
       }
 
   event-cleanup:
     - flag <player> dRegions.rateLimit.entity-interact.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.entity-interact.%target%:false
     - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not interact with %1%s here!'
       }
 
 
 dRegions_Flag_Entity-Interactlist:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity Interact List<&4>]"
   lore:
   - <&5>List of entities used by entity-interact flag
   command_entryType: mob
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Entity-Interact
   flag_takeGroup: false
   flag_help: List flag used with entity-interact flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Entity-Explode:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Explode<&4>]"
   lore:
   - <&5>Can entities explode
   event_hook: entity-explode
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether entities will be able to explode in this region. Defaults to allow all. Use entity-explodelist flag to specify entities types.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-explode.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-explode]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-explodelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-explode]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-explodelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.entity-explode.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.entity-explode.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.entity-explode.%target%:false' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Entity-ExplodeList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Explodelist<&4>]"
   lore:
   - <&5>List of mobs used by entity-explode flag
   command_entryType: entity
   command_verifyEntry: <el@val[creeper|ender_crystal|ender_dragon|primed_tnt|minecart_tnt|fireball|small_fireball|wither|wither_skull].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Entity-Explode
   flag_takeGroup: false
   flag_help: List flag used with entity-explode flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities. Valid entities<&co> creeper, ender_crystal, ender_dragon, primed_tnt, minecart_tnt, fireball, small_fireball, wither, wither_skull
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Entity-Grief:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Grief<&4>]"
   lore:
   - <&5>Can entities alter blocks
   event_hook: entity-changeBlock
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether entities will be able to alter blocks in this region. Defaults to allow all. Use entity-grieflist flag to specify entities types.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-grief.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - run locally offthread delay:1t def:<c.entity.uuid>
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-grief]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-grieflist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-grief]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-grieflist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.entity-grief.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.entity-grief.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.entity-grief.%target%:false' 'id:dRegions_%world%_cache'
     - run locally offthread delay:1t def:<c.entity.uuid>
 
   offthread:
     - ^flag server dRegions.EntityGrief.%1%
     - ^wait 3s
     - ^flag server dRegions.EntityGrief.%1%:!
 
 
 dRegions_Flag_Entity-GriefList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Grieflist<&4>]"
   lore:
   - <&5>List of mobs used by entity-grief flag
   command_entryType: entity
   command_verifyEntry: <el@val[enderman|sheep|zombie|squid].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Entity-Grief
   flag_takeGroup: false
   flag_help: List flag used with entity-grief flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities. Valid entities<&co> sheep, enderman, zombie, squid
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Entity-Drops-OnDeath:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Drops-OnDeath<&4>]"
   lore:
   - <&5>Can mobs drop items
   event_hook: EntityDies
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.entity-drops-ondeath.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine no_drops
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-drops-ondeath]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|entity-drops-ondeathlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-drops-ondeath]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-drops-ondeathlist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.entity-drops-ondeath.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.entity-drops-ondeath.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.entity-drops-ondeath.%target%:false' 'id:dRegions_%world%_cache'
     - determine no_drops
 
 
 dRegions_Flag_Entity-Drops-OnDeathList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Drops-OnDeathlist<&4>]"
   lore:
   - <&5>List of mobs used by entity-drops-ondeath flag
   command_entryType: entity
   command_verifyEntry: <def[value].is[matches].to[entity].not>
   flag_type: list
   flag_parent: dRegions_Flag_Entity-Drops-OnDeath
   flag_takeGroup: false
   flag_help: List flag used with entity-drops-ondeath flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of entities.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Fire-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Fire-Spread<&4>]"
   lore:
   - <&5>Can fire spread
   event_hook: fireFrom-Spread
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether fire will be able to spread in this region. Defaults to allow all. Use fire-spreadblocks flag to specify blocks to check when spreading.
 #  flag_help: This flag is temporarily disabled. Please use the fire-destroyblocks flag.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.fire-spread.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|fire-spread]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.fire-spread.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|fire-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.fire-spread.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-spread]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.fire-spread.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.fire-spread.%target%:none' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Fire-SpreadBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Fire-Spread-BlockList<&4>]"
   lore:
   - <&5>List of blocks involved in fire spread
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Fire-Spread
   flag_takeGroup: false
   flag_help: List flag used with fire-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Fire-Destroy:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Fire-Destroy<&4>]"
   lore:
   - <&5>Can fire destroy blocks
   event_hook: fire-destroyBlocks
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether fire will be able to spread to and destroy blocks in this region. Defaults to allow all. Use fire-destroyblocks flag to specify blocks to check when spreading.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.fire-destroy.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - define flagVal 'null'
           - foreach stop
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|fire-destroy]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.fire-destroy.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|fire-destroyblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.fire-destroy.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-destroy]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|fire-destroyblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.fire-destroy.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.fire-destroy.%target%:none' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Fire-DestroyBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Fire-Destroy-BlockList<&4>]"
   lore:
   - <&5>List of blocks involved in fire-destroy
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Fire-Destroy
   flag_takeGroup: false
   flag_help: List flag used with fire-destroy flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Lightning-Strikes:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Lightning-Strikes<&4>]"
   lore:
   - <&5>Can lightning strike
   event_hook: lightning-strikes
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether lightning will be able to strike in this region. Defaults to allow all. Use lightning-strikeblocks flag to specify blocks to check when striking.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.lightning-strikes.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lightning-strikes]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.lightning-strikes.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lightning-strikesblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.lightning-strikes.%target%:true' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lightning-strikes]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lightning-strikesblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.lightning-strikes.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.lightning-strikes.%target%:none' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Lightning-StrikesBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Lightning-StrikesBlocks<&4>]"
   lore:
   - <&5>List of blocks involved in lightning strikes
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Lightning-Strikes
   flag_takeGroup: false
   flag_help: List flag used with lightning-strike flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Water-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Water-Spread<&4>]"
   lore:
   - <&5>Can Water spread
   event_hook: WaterSpread
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether water will be able to spread in this region. Defaults to allow all. Use water-spreadblocks flag to specify blocks to check when spreading.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.water-spread.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|water-spread]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.water-spread.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|water-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.water-spread.%target%:true' 'id:dRegions_%world%_cache'
       - queue clear
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|water-spread]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|water-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.water-spread.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.water-spread.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.water-spread.%target%:false' 'id:dRegions_%world%_cache'
     - queue clear
 
 
 dRegions_Flag_Water-SpreadBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Water-Spread-BlockList<&4>]"
   lore:
   - <&5>List of blocks involved in water spread
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Water-Spread
   flag_takeGroup: false
   flag_help: List flag used with water-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Lava-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Lava-Spread<&4>]"
   lore:
   - <&5>Can Lava spread
   event_hook: LavaSpread
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether lava will be able to spread in this region. Defaults to allow all. Use lava-spreadblocks flag to specify blocks to check when spreading.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
 #  event:
 #    - foreach %orderedRegions% {
 #      - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lava-spread]>'
 #      - define region '%value%'
 #      - if %flagVal% != null {
 #        - foreach stop
 #        }
 #      }
 #    - if %flagVal% != null {
 #      - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lava-spreadblocks].replace[, ].with[|].as_list>'
 #      - inject s@dRegions_Flags_Processors p:state-withTarget
 #      }
 
 #  event-global:
 #    - define orderedRegions 'li@__global__'
 #    - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spread]>'
 #    - if %flagVal% != null {
 #      - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spreadblocks].replace[, ].with[|].as_list>'
 #      - inject s@dRegions_Flags_Processors p:state-withTarget
 #      }
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.lava-spread.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lava-spread]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|lava-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:true' 'id:dRegions_%world%_cache'
       - queue clear
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spread]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lava-spreadblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.lava-spread.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.lava-spread.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.lava-spread.%target%:false' 'id:dRegions_%world%_cache'
 
 
 
 dRegions_Flag_Lava-SpreadBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Lava-Spread-BlockList<&4>]"
   lore:
   - <&5>List of blocks involved in lava spread
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Lava-Spread
   flag_takeGroup: false
   flag_help: List flag used with lava-spread flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Snow-Fall:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Snow-Fall<&4>]"
   lore:
   - <&5>Can Snow accumulate
   event_hook: blockForm-snow
   event_priority: 10
   flag_type: state-withTarget
   flag_takeGroup: false
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether snow will be able to accumulate on the ground in this region. Defaults to allow all. Use snow-fallblocks flag to specify blocks below the snow to check when forming.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define region '%value%'
       - define cache '<yaml[dRegions_%world%_cache].read[cache.state-withTarget.%value%.snow-fall.%target%]||null>'
       - if %cache% == none {
         - define flagVal 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|snow-fall]>'
       - if %flagVal% != null {
         - foreach stop
         }
         else {
         - yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:none' 'id:dRegions_%world%_cache'
         }
       }
     - if %flagVal% != null {
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|snow-fallblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:true' 'id:dRegions_%world%_cache'
       - queue clear
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-fall]>'
     - if %flagVal% != null {
       - define region '__global__'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-fallblocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget
       - yaml set 'cache.state-withTarget.__global__.snow-fall.%target%:true' 'id:dRegions_%world%_cache'
       }
       else {
       - yaml set 'cache.state-withTarget.__global__.snow-fall.%target%:none' 'id:dRegions_%world%_cache'
       }
 
   event-cleanup:
     - yaml set 'cache.state-withTarget.%region%.snow-fall.%target%:false' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Snow-FallBlocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Snow-Fall-BlockList<&4>]"
   lore:
   - <&5>List of blocks to check under snow
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Snow-Fall
   flag_takeGroup: false
   flag_help: List flag used with snow-fall flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Ice-Form:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Ice-Form<&4>]"
   lore:
   - <&5>Can water turn into ice
   event_hook: blockForm-ice
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether water will be able to turn into ice in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.ice-form]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|ice-form]>'
       - if %flagVal% != null {
         - if %flagVal% {
           - yaml set 'cache.boolean.%value%.ice-form:true' 'id:dRegions_%world%_cache'
           - foreach stop
           }
         - yaml set 'cache.boolean.%value%.ice-form:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.%value%.ice-form:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|ice-form]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.ice-form:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       }
     - yaml set 'cache.boolean.__global__.ice-form:true' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Ice-Melt:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Ice-Melt<&4>]"
   lore:
   - <&5>Can ice melt
   event_hook: blockFade-ice
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether ice can melt in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.ice-melt]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|ice-melt]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.ice-melt:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.ice-melt:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.ice-melt:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|ice-melt]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.ice-melt:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       }
     - yaml set 'cache.boolean.__global__.ice-melt:true' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Snow-Melt:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Snow-Melt<&4>]"
   lore:
   - <&5>Can snow melt
   event_hook: blockFade-snow
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether snow can melt in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.snow-melt]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|snow-melt]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.snow-melt:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.snow-melt:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.snow-melt:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|snow-melt]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.snow-melt:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       }
     - yaml set 'cache.boolean.__global__.snow-melt:true' 'id:dRegions_%world%_cache'
 
 
 dRegions_Flag_Soil-Dry:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Soil-Dry<&4>]"
   lore:
   - <&5>Can soil dry up
   event_hook: blockFade-soil
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether soil can dry in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.soil-dry]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|soil-dry]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.soil-dry:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.soil-dry:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.soil-dry:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|soil-dry]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.soil-dry:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.soil-dry:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Trample-Crops-Player:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Trample-Crops-Player<&4>]"
   lore:
   - <&5>Can players trample crops
   event_hook: trample-crops-player
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether players can trample crops in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.trample-crops-player]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|trample-crops-player]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.trample-crops-player:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.trample-crops-player:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.trample-crops-player:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|trample-crops-player]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.trample-crops-player:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.trample-crops-player:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Trample-Crops-Entity:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Trample-Crops-Entity<&4>]"
   lore:
   - <&5>Can entities trample crops
   event_hook: trample-crops-entity
   event_priority: 10
   flag_type: boolean
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether entities can trample crops in this region. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.trample-crops-entity]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|trample-crops-entity]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.trample-crops-entity:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.trample-crops-entity:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.trample-crops-entity:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|trample-crops-entity]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.trample-crops-entity:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.trample-crops-entity:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Mushroom-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mushroom-Spread<&4>]"
   lore:
   - <&5>Can Mushrooms spread
   event_hook: MushroomSpread
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether mushrooms will be able to spread in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.mushroom-spread]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mushroom-spread]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.mushroom-spread:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.mushroom-spread:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.mushroom-spread:none' 'id:dRegions_%world%_cache'
       }
 
   event-Global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mushroom-spread]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.mushroom-spread:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.mushroom-spread:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Grass-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Grass-Spread<&4>]"
   lore:
   - <&5>Can Grass spread
   event_hook: GrassSpread
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether grass will be able to spread in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.grass-spread]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|grass-spread]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.grass-spread:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.grass-spread:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.grass-spread:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|grass-spread]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.grass-spread:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.grass-spread:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Mycel-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Mycel-Spread<&4>]"
   lore:
   - <&5>Can Mycelium spread
   event_hook: MycelSpread
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether mycelium will be able to spread in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.mycel-spread]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|mycel-spread]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.mycel-spread:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.mycel-spread:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.mycel-spread:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|mycel-spread]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.mycel-spread:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.mycel-spread:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Vines-Spread:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Vine-Growth<&4>]"
   lore:
   - <&5>Can Vines grow
   event_hook: VinesSpread
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether vines will be able to grow in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.vines-spread]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|vines-spread]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.vines-spread:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.vines-spread:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.vines-spread:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|vines-spread]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.vines-spread:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.vines-spread:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Leaf-Decay:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Leaf-Decay<&4>]"
   lore:
   - <&5>Can leaves decay
   event_hook: leaf-decay
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether leaves will be able to decay in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.leaf-decay]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|leaf-decay]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.leaf-decay:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.leaf-decay:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.leaf-decay:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|leaf-decay]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.leaf-decay:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.leaf-decay:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Falling-Sand:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Falling-Sand<&4>]"
   lore:
   - <&5>Can sand fall
   event_hook: physics-sand
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether sand will be able to fall in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.falling-sand]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|falling-sand]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.falling-sand:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.falling-sand:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.falling-sand:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|falling-sand]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.falling-sand:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.falling-sand:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Falling-Gravel:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Falling-Gravel<&4>]"
   lore:
   - <&5>Can gravel fall
   event_hook: physics-gravel
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether gravel will be able to fall in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.falling-gravel]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|falling-gravel]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.falling-gravel:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.falling-gravel:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.falling-gravel:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|falling-gravel]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.falling-gravel:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.falling-gravel:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Pistons:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Pistons<&4>]"
   lore:
   - <&5>Can pistons be activated
   event_hook: pistons
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether pistons can be activated in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.pistons]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pistons]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.pistons:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.pistons:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.pistons:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pistons]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.pistons:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.pistons:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Lighter:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Lighter<&4>]"
   lore:
   - <&5>Who can use the flint and steel in a region
   event_hook: fireFrom-Lighter
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use a lighter in this region'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|lighter]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|lighter]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Bucket-Fill:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Bucket-Fill<&4>]"
   lore:
   - <&5>Who can fill a bucket in a region
   event_hook: fillBucket
   event_priority: 5
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not fill a bucket in this region'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|bucket-fill]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|bucket-fill]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Bucket-Empty:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Bucket-Empty<&4>]"
   lore:
   - <&5>Who can fill a bucket in a region
   event_hook: emptyBucket
   event_priority: 5
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not empty a bucket in this region'
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|bucket-empty]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|bucket-empty]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
 
 dRegions_Flag_Hanging-Place:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Hanging-Place<&4>]"
   lore:
   - <&5>Who can place item frames and paintings
   event_hook: hangingPlace
   event_priority: 0
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not hang that in this region'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|hanging-place]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hanging-place]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Hanging-Break:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Hanging-Break<&4>]"
   lore:
   - <&5>Who can break item frames and paintings
   event_hook: hangingBreak
   event_priority: 0
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break that in this region'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|hanging-break]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|hanging-break]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Sleep:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Sleep<&4>]"
   lore:
   - <&5>Who can Sleep
   event_hook: sleep
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not sleep here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|sleep]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       - if %flagObj% == null {
         - define flagObj 'deny/nonmembers'
         }
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|sleep]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Player-Drops:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-Drops<&4>]"
   lore:
   - <&5>Who can drop items
   event_hook: player-drop
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not drop items here.'
       }
 
   event:
     - foreach %orderedRegions% {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-drops]>'
       - define region '%value%'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup
         - foreach stop
         }
       }
 
   event-global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-drops]>'
     - if %flagObj% != null {
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup-global
       }
 
 
 dRegions_Flag_Player-Drops-OnDeath:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-Drops-OnDeath<&4>]"
   lore:
   - <&5>Who can drop items when they die
   event_hook: PlayerDies
   event_priority: 20
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - determine NO_DROPS
 
   event:
     - foreach %orderedRegions% {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-drops-ondeath]>'
       - define region '%value%'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup
         - foreach stop
         }
       }
 
   event-global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-drops-ondeath]>'
     - if %flagObj% != null {
       - define player <player>
       - inject s@dRegions_Flags_Processors p:state-withGroup-global
       }
 
 
 dRegions_Flag_Player-KeepItems:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-KeepItems<&4>]"
   lore:
   - <&5>Can players keep items on death
   event_hook: PlayerDies
   event_priority: 10
   flag_type: state
   flag_takeGroup: true
   flag_defaultValue: deny/all
   flag_help: State flag controlling whether players will keep their items when they die in a region. Default is to deny all. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-keepitems]>'
       - if %flagObj% != null {
         - if <def[flagObj].split[/].get[1]> == allow {
           - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%world%|<player>]> {
             - run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
             - determine NO_DROPS_NO_XP
             - foreach stop
             }
           }
           else {
           - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%world%|<player>]> {
             - run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
             - determine NO_DROPS_NO_XP
             - foreach stop
             }
           }
         }
       }
 
   event-global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-keepitems]>'
     - if %flagObj% != null {
       - if <def[flagObj].split[/].get[1]> == allow {
         - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|<player>]> {
           - run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
           - determine NO_DROPS_NO_XP
           }
         }
         else {
         - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|<player>]> {
           - run locally returnItems 'def:<player.inventory.list_contents.escaped>|<player.equipment.escaped>' delay:2t
           - determine NO_DROPS_NO_XP
           }
         }
       }
 
   returnItems:
     - inventory clear
     - run s@dRegions_Msg delay:1t 'def:<&9>You died, but your inventory is safe!'
     - inventory set 'd:<player.inventory>' 'o:<def[1].unescaped>'
     - define equipment '<def[2].unescaped>'
     - equip <player> 'boots:<def[equipment].get[1]||i@air>' 'legs:<def[equipment].get[2]||i@air>' 'chest:<def[equipment].get[3]||i@air>' 'head:<def[equipment].get[4]||i@air>'
 
 
 dRegions_Flag_Spawn:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Spawn<&4>]"
   lore:
   - <&5>Region spawn point.
   event_hook: playerDies
   event_priority: 5
   flag_type: location
   flag_takeGroup: true
   flag_help: Set the location players will respawn at if they die in this region. Default is to have no effect so normal respawn mechanics will apply. Takes the -g group switch. Specify the value as `here` to use your current location, or specify a valid location in the `x,y,z,world` format.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if !<player.has_permission[dregions.admin]||<player.is_op||false>> {
       - if <proc[dRegions_RegionOverlaps].context[<def[flagValue]>/<def[flagValue]>|%world%|<player>]> {
         - run s@dRegions_Msg delay:1t 'def:<&c>You can not use that location!'
         - queue clear
         }
       }
 
   event:
     - ^foreach <def[2].unescaped> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%1%|%value%|spawn]>'
       - if ( %flagObj% != null ) && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%value%|%1%|<player>]> {
 #        - adjust <player> 'location:<def[flagObj].split[/].get[1].as_location>'
         - flag <player> 'dRegions_Respawn:<def[flagObj].split[/].get[1].as_location>'
         - foreach stop
         }
       }
 
   event-global:
     - ^define flagObj '<proc[dRegions_GetInheritedFlag].context[%1%|__global__|spawn]>'
     - ^if ( %flagObj% != null ) && <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%1%|<player>]> {
 #      - adjust <player> 'location:<def[flagObj].split[/].get[1].as_location>'
       - flag <player> 'dRegions_Respawn:<def[flagObj].split[/].get[1].as_location>'
       }
 
 
 dRegions_Flag_Player-Pickup:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-Pickup<&4>]"
   lore:
   - <&5>Who can pickup items
   event_hook: player-pickup
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not pick up items here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-pickup]>'
         - define region '%value%'
         - if %flagObj% != null {
           - define player <player>
           - inject s@dRegions_Flags_Processors p:state-withGroup
           - foreach stop
           }
         }
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-pickup]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Entity-Break-Painting:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Break-Painting<&4>]"
   lore:
   - <&5>Can Entities break paintings
   event_hook: entity-break-painting
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether mobs will be able to destroy paintings in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.entity-break-painting]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-break-painting]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.entity-break-painting:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.entity-break-painting:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.entity-break-painting:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-break-painting]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.entity-break-painting:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.entity-break-painting:none' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_Entity-Break-ItemFrame:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Entity-Break-ItemFrame<&4>]"
   lore:
   - <&5>Can Entities break item frames
   event_hook: entity-break-itemframe
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether mobs will be able to destroy item frames in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.entity-break-itemframe]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|entity-break-itemframe]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.entity-break-itemframe:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.entity-break-itemframe:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.entity-break-itemframe:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|entity-break-itemframe]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.entity-break-itemframe:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.entity-break-itemframe:true' 'id:dRegions_%world%_cache'
       }
 
 
 dRegions_Flag_PVP:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>PVP<&4>]"
   lore:
   - <&5>Can players damage each other
   event_hook: player_damage_player
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether players can attack eachother in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.pvp]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - remove <c.projectile||li@>
         - run locally msg delay:1t
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|pvp]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - yaml set 'cache.boolean.%value%.pvp:false' 'id:dRegions_%world%_cache'
           - remove <c.projectile||li@>
           - run locally msg delay:1t
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.pvp:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.pvp:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|pvp]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - yaml set 'cache.boolean.__global__.pvp:false' 'id:dRegions_%world%_cache'
         - remove <c.projectile||li@>
         - run locally msg delay:1t
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.pvp:true' 'id:dRegions_%world%_cache'
       }
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You are in a no PVP zone.'
       }
 
 
 dRegions_Flag_Potion-Throw:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Potion-Throw<&4>]"
   lore:
   - <&5>Can potions be thrown in this region
   event_hook: throwPotion
   event_priority: 10
   flag_type: boolean
   flag_takeGroup: false
   flag_defaultValue: true
   flag_globalDefault: true
   flag_help: Boolean flag controlling whether potions can be thrown and broken in this region. Set to true or false. Defaults to true.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - foreach %orderedRegions% {
       - define cache '<yaml[dRegions_%world%_cache].read[cache.boolean.%value%.potion-throw]||null>'
       - if %cache% == none {
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - queue clear
           }
         - if <player.is[!=].to[null]||false> {
           - run locally msg delay:1t
           }
         - determine cancelled
         }
       - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|potion-throw]>'
       - if %flagVal% != null {
         - if !%flagVal% {
           - if <player.is[!=].to[null]||false> {
             - run locally msg delay:1t
             }
           - yaml set 'cache.boolean.%value%.potion-throw:false' 'id:dRegions_%world%_cache'
           - determine cancelled
           }
         - yaml set 'cache.boolean.%value%.potion-throw:true' 'id:dRegions_%world%_cache'
         - foreach stop
         }
       - yaml set 'cache.boolean.%value%.potion-throw:none' 'id:dRegions_%world%_cache'
       }
 
   event-global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|potion-throw]>'
     - if %flagVal% != null {
       - if !%flagVal% {
         - if <player.is[!=].to[null]||false> {
           - run locally msg delay:1t
           }
         - yaml set 'cache.boolean.__global__.potion-throw:false' 'id:dRegions_%world%_cache'
         - determine cancelled
         }
       - yaml set 'cache.boolean.__global__.potion-throw:true' 'id:dRegions_%world%_cache'
       }
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not||false> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not throw potions here.'
       }
 
 
 dRegions_Flag_Potion-Drink:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Potion-Drink<&4>]"
   lore:
   - <&5>Who can drink potions
   event_hook: drinkPotion
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not drink potions here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|potion-drink]>'
         - define region '%value%'
         - if %flagObj% != null {
           - define player <player>
           - inject s@dRegions_Flags_Processors p:state-withGroup
           - foreach stop
           }
         }
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|potion-drink]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Enderpearl:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Enderpearl<&4>]"
   lore:
   - <&5>Who can use enderpearls
   event_hook: enderPearl
   event_priority: 10
   flag_type: state-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event-cleanup:
     - run locally msg delay:1t
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use enderpearls here.'
       }
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|enderpearl]>'
         - define region '%value%'
         - if %flagObj% != null {
           - define player <player>
           - inject s@dRegions_Flags_Processors p:state-withGroup
           - foreach stop
           }
         }
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|enderpearl]>'
       - if %flagObj% != null {
         - define player <player>
         - inject s@dRegions_Flags_Processors p:state-withGroup-global
         }
       }
 
 
 dRegions_Flag_Block-Place:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Block-Place<&4>]"
   lore:
   - <&5>Can players place blocks.
   event_hook: blockPlace
   event_priority: 5
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: true
   flag_help: State flag controlling whether players will be able to place blocks in this region. Defaults to allow all. Use block-placelist flag to specify block types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.block-place.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|block-place]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.block-place.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|block-placelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.block-place.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-place]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-placelist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.block-place.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.block-place.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.block-place.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.block-place.%target%:false
     - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not place %1% in this region!'
       }
 
 
 dRegions_Flag_Block-PlaceList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Block-PlaceList<&4>]"
   lore:
   - <&5>List of blocks used by block-place flag
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Block-Place
   flag_takeGroup: false
   flag_help: List flag used with block-place flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Block-Break:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Block-Break<&4>]"
   lore:
   - <&5>Can players break blocks.
   event_hook: blockBreak
   event_priority: 5
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: true
   flag_help: State flag controlling whether players will be able to break blocks in this region. Defaults to allow all. Use block-breaklist flag to specify block types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.block-break.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|block-break]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.block-break.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|block-breaklist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.block-break.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-break]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|block-breaklist].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.block-break.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.block-break.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.block-break.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.block-break.%target%:false
     - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not break %1% in this region!'
       }
 
 
 dRegions_Flag_Block-BreakList:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Block-BreakList<&4>]"
   lore:
   - <&5>List of blocks used by block-break flag
   command_entryType: block
   command_verifyEntry: <def[value].as_material.is_block.not||true>
   flag_type: list
   flag_parent: dRegions_Flag_Block-Break
   flag_takeGroup: false
   flag_help: List flag used with block-break flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Chest-Access:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Chest-Access<&4>]"
   lore:
   - <&5>Can players open containers.
   event_hook: openContainer
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_name: chest-access
   flag_targetList: chest-access-blocks
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   flag_help: State flag controlling whether players will be able to open containers in this region. Defaults to deny nonmembers. Use chest-access-blocks flag to specify container blocks types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.chest-access.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|chest-access]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.cache.%world%.%value%.chest-access.%target%:none
         }
       }
     - if %flagObj% == null {
       - define flagObj 'deny/nonmembers'
       }
     - define player <player>
     - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|chest-access-blocks].replace[, ].with[|].as_list>'
     - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
     - if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.chest-access.%target%:true
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|chest-access]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|chest-access-blocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.chest-access.%target%:true
       }
       else {
       - flag <player> dRegions.cache.%world%.__global__.chest-access.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.chest-access.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.chest-access.%target%:false
     - run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not open %1%s in this region!'
       }
 
 
 dRegions_Flag_Chest-Access-Blocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Chest-Access-Blocks<&4>]"
   lore:
   - <&5>List of blocks used by chest-access flag
   command_entryType: container
   command_verifyEntry: <el@val[chest|ender_chest|locked_chest|trapped_chest|dispenser|hopper|dropper].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Chest-Access
   flag_takeGroup: false
   flag_help: List flag used with chest-access flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid container blocks<&co> chest, ender_chest, locked_chest, trapped_chest, dispenser, hopper, and dropper.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Door-Access:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Door-Access<&4>]"
   lore:
   - <&5>Can players open doors.
   event_hook: openDoor
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_name: Door-Access
   flag_targetList: Door-Access-Doors
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   flag_help: State flag controlling whether players will be able to open doors in this region. Defaults to allow all. Use door-access-doors flag to specify door blocks types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.door-access.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|door-access]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.door-access.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|door-access-doors].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.door-access.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|door-access]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|door-access-doors].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.door-access.%target%:true
       }
       else {
       - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.door-access.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.door-access.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.door-access.%target%:false
     - run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not open %1%s in this region!'
       }
 
 
 dRegions_Flag_Door-Access-Doors:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Door-Access-Doors<&4>]"
   lore:
   - <&5>List of doors used by doors-access flag
   command_entryType: door
   command_verifyEntry: <el@val[trap_door|iron_trapdoor|wooden_door|iron_door_block|spruce_door|birch_door|jungle_door|dark_oak_door|acacia_door|fence_gate|spruce_fence_gate|birch_fence_gate|jungle_fence_gate|dark_oak_fence_gate|acacia_fence_gate].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Door-Access
   flag_takeGroup: false
   flag_help: List flag used with door-access flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid door blocks<&co> trap_door, iron_trapdoor, wooden_door, iron_door_block, spruce_door, birch_door, jungle_door, dark_oak_door, acacia_door, fence_gate, spruce_fence_gate, birch_fence_gate, jungle_fence_gate, dark_oak_fence_gate, and acacia_fence_gate.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Use-Switches:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Use-Switches<&4>]"
   lore:
   - <&5>Can players interact with switches.
   event_hook: useSwitch
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_name: Use-Switches
   flag_targetList: Use-Switches-List
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   flag_help: State flag controlling whether players will be able to use switches in this region. Defaults to deny nonmembers. Use use-switches-list flag to specify switch block types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.use-switches.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|use-switches]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.cache.%world%.%value%.use-switches.%target%:none
         }
       }
     - if %flagObj% == null {
       - define flagObj 'deny/nonmembers'
       }
     - define player <player>
     - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|use-switches-list].replace[, ].with[|].as_list>'
     - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
     - if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.use-switches.%target%:true
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-switches]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-switches-list].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.use-switches.%target%:true
       }
       else {
       - flag <player> dRegions.cache.%world%.__global__.use-switches.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.use-switches.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.use-switches.%target%:false
     - run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use %1%s in this region!'
       }
 
 
 dRegions_Flag_Use-Switches-List:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Use-Switches-List<&4>]"
   lore:
   - <&5>List of switches used by use-switches flag
   command_entryType: switch
   command_verifyEntry: <el@val[lever|wood_button|stone_button|wood_plate|stone_plate|iron_plate|gold_plate].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Use-Switches
   flag_takeGroup: false
   flag_help: List flag used with use-switches flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid switch blocks<&co> lever, wood_button, stone_button, wood_plate, stone_plate, iron_plate, and gold_plate.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Use-Utilities:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Use-Utilities<&4>]"
   lore:
   - <&5>Can players use utility blocks.
   event_hook: useUtility
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_name: Use-Utilities
   flag_targetList: Use-Utilities-Blocks
   flag_takeGroup: true
   flag_defaultValue: deny/nonmembers
   flag_globalDefault: none
   region_highestOnly: true
   flag_help: State flag controlling whether players will be able to use utility blocks in this region. Defaults to deny nonmembers. Use use-utilities-blocks flag to specify utility blocks. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.use-utilities.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
           - queue clear
           }
         - if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:false d:10s
         - run locally msg delay:1t 'def:<def[target].to_lowercase.replace[_].with[ ]>'
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|use-utilities]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.cache.%world%.%value%.use-utilities.%target%:none
         }
       }
     - if %flagObj% == null {
       - define flagObj 'deny/nonmembers'
       }
     - define player <player>
     - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|use-utilities-blocks].replace[, ].with[|].as_list>'
     - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
     - if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.use-utilities.%target%:true
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-utilities]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|use-utilities-blocks].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.use-utilities.%target%:true
       }
       else {
       - flag <player> dRegions.cache.%world%.__global__.use-utilities.%target%:none
       }
 
   event-cleanup:
     - if %sameRegion% flag <player> dRegions.rateLimit.use-utilities.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.use-utilities.%target%:false
     - run locally msg delay:1t 'def:<c.location.material.name.replace[_].with[ ]>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - run s@dRegions_Msg delay:1t 'def:<&c><&o>You can not use %1%s in this region!'
       }
 
 
 dRegions_Flag_Use-Utilities-Blocks:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Use-Utilities-Blocks<&4>]"
   lore:
   - <&5>List of blocks used by use-utilities flag
   command_entryType: utility
   command_verifyEntry: <el@val[workbench|furnace|burning_furnace|anvil|cauldron|brewing_stand|enchantment_table|note_block|jukebox|beacon].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Use-Utilities
   flag_takeGroup: false
   flag_help: List flag used with use-utilities flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of blocks. Valid utility blocks<&co> workbench, furnace, burning_furnace, anvil, brewing_stand, cauldron, enchantment_table, note_block, jukebox, and beacon.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Player-Damage:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-Damage<&4>]"
   lore:
   - <&5>Can players take damage.
   event_hook: playerDamaged
   event_priority: 10
   flag_type: state-withTarget-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: false
   flag_help: State flag controlling whether players will take damage in this region. Defaults to allow all. Use player-damage-types flag to specify damage types. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define thisRegion '<def[orderedRegions].get[1]>'
     - foreach %orderedRegions% {
       - define cache '<player.flag[dRegions.cache.%world%.%value%.player-damage.%target%]||null>'
       - if %cache% == none {
         - define flagObj 'null'
         - foreach next
         }
       - if %cache% != null {
         - if %cache% {
           - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
           - queue clear
           }
         - adjust <player> 'fire_time:0'
         - flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
         - determine cancelled
         }
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|player-damage]>'
       - if %flagObj% != null {
         - define region '%value%'
         - foreach stop
         }
         else {
         - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
         - flag <player> dRegions.cache.%world%.%value%.player-damage.%target%:none
         }
       }
     - if %flagObj% != null {
       - define player <player>
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|player-damage-types].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.%thisRegion%.player-damage.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
       }
 
   event-global:
     - define thisRegion '__global__'
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-damage]>'
     - if %flagObj% != null {
       - define orderedRegions 'li@__global__'
       - define player '<player>'
       - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|player-damage-types].replace[, ].with[|].as_list>'
       - inject s@dRegions_Flags_Processors p:state-withTarget-withGroup
       - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.player-damage.%target%:true
       }
       else {
       - flag <player> dRegions.rateLimit.player-damage.%target%:true d:10s
       - flag <player> dRegions.cache.%world%.__global__.player-damage.%target%:none
       }
 
   event-cleanup:
     - flag <player> dRegions.rateLimit.player-damage.%target%:false d:10s
     - flag <player> dRegions.cache.%world%.%thisRegion%.player-damage.%target%:false
     - adjust <player> 'fire_time:0'
 
 
 dRegions_Flag_Player-Damage-Types:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Player-Damage-Types<&4>]"
   lore:
   - <&5>List of damage types used by player-damage flag
   command_entryType: cause
   command_verifyEntry: <el@val[BLOCK_EXPLOSION|CONTACT|CUSTOM|DROWNING|ENTITY_ATTACK|ENTITY_EXPLOSION|FALL|FALLING_BLOCK|FIRE|FIRE_TICK|LAVA|LIGHTNING|MAGIC|MELTING|POISON|PROJECTILE|STARVATION|SUFFOCATION|SUICIDE|THORNS|VOID|WITHER].as_list.contains[<def[value]>].not>
   flag_type: list
   flag_parent: dRegions_Flag_Player-Damage
   flag_takeGroup: false
   flag_help: List flag used with player-damage flag. To add to the list, use the -a switch. To remove from list use the -r switch. Provide a space separated list of damage types. Valid damage types<&co> block_explosion, contact, custom, drowning, entity_attack, entity_explosion, fall, falling_block, fire, fire_tick, lava, lightning, magic, melting, poison, projectile, starvation, suffocation, suicide, thorns, void, and wither.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_verifiedList
 
 
 dRegions_Flag_Commands:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Commands<&4>]"
   lore:
   - <&5>Can players use commands.
   event_hook: playerCommand
   event_priority: 10
   flag_type: state-withTargetString-withGroup
   flag_takeGroup: true
   flag_defaultValue: none
   flag_globalDefault: none
   region_highestOnly: false
   flag_help: State flag controlling whether players can use commands in this region. Defaults to allow all. Use commands-list flag to specify commands. Takes the -g group switch.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define player <player>
       - define flag 'commands'
       - define flag-targetList 'commands-list'
       - define delimiter ' ; '
       - inject s@dRegions_Flags_Processors p:state-withTargetString-withGroup
       }
 
   event-global:
     - if !<player.has_permission[dRegions.admin]||<player.is_op||false>> {
       - define player <player>
       - define flag 'commands'
       - define flag-targetList 'commands-list'
       - define delimiter ' ; '
       - inject s@dRegions_Flags_Processors p:state-withTargetString-withGroup-Global
       }
 
   event-cleanup:
     - run locally msg delay:1t 'def:<def[target].split[ ].parse[replace[regex:^].with[<&e>]].as_string>'
 
   msg:
     - ^if <player.has_flag[dRegions_Message_Cooldown].not> {
       - flag <player> dRegions_Message_Cooldown duration:3s
       - define lines '<proc[dRegions_LineWrap].context[You can not use the %1% <&c>command in this region!|45]>'
       - foreach %lines% {
         - run s@dRegions_Msg delay:1t 'def:<&c>%value%'
         }
       }
 
 
 dRegions_Flag_Commands-List:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Commands-List<&4>]"
   lore:
   - <&5>List of commands used by commands flag
   command_entryType: cause
   flag_type: list
   flag_parent: dRegions_Flag_Commands
   flag_takeGroup: false
   flag_help: List flag used with commands flag. To add to the list, use the -a switch. To remove from list use the -r switch. Add/remove one command at a time!
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - inject s@dRegions_Flags_CommandProcessors p:command_stringList
 
 
 dRegions_Flag_Heal-Amount:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Heal-Amount<&4>]"
   lore:
   - <&5>The amount to heal or harm.
   event_hook: regionEnter
   event_priority: 10
   flag_type: number
   flag_help: Set the amount to heal or hurt a player while inside a region. Defaults to no effect. Positive number will heal players, negative numbers will damage players.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define healAmount '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-amount]>'
     - if %healAmount% != null {
       - define healDelay '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-delay]>'
       - if %healDelay% == null {
         - define healDelay '5'
         }
       - define healMax '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-max]>'
       - if %healMax% == null {
         - define healMax '20'
         }
       - define healMax '<tern[<def[healMax].is[MORE].than[<player.health.max>]>]:<player.health.max>||%healMax%>'
       - define healMin '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|heal-min]>'
       - if %healMin% == null {
         - define healMin '0'
         }
       - if <queue.exists[dRegions_Heal_<player.name>]> {
         - queue q@dRegions_Heal_<player.name> clear
         }
       - run locally healTask delay:1t 'def:%world%|%region%|%healAmount%|%healDelay%|%healMax%|%healMin%' id:dRegions_Heal_<player.name>
       }
 
   event-global:
     - define healAmount '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-amount]>'
     - if %healAmount% != null {
       - define healDelay '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-delay]>'
       - if %healDelay% == null {
         - define healDelay '5'
         }
       - define healMax '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-max]>'
       - if %healMax% == null {
         - define healMax '20'
         }
       - define healMax '<tern[<def[healMax].is[MORE].than[<player.health.max>]>]:<player.health.max>||%healMax%>'
       - define healMin '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|heal-min]>'
       - if %healMin% == null {
         - define healMin '0'
         }
       - if <queue.exists[dRegions_Heal_<player.name>]> {
         - queue q@dRegions_Heal_<player.name> clear
         }
       - run locally healTask delay:1t 'def:%world%|__global__|%healAmount%|%healDelay%|%healMax%|%healMin%' id:dRegions_Heal_<player.name>
       }
 
   healTask:
     - while <player.is_online> {
       - define world '<player.world.name>'
       - if %world% != %1% {
         - while stop
         }
       - define regionPri 'li@'
       - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - if <def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]> != %2% {
         - while stop
         }
       - if <player.gamemode.id> == 1 {
         - wait 1s
         - while next
         }
       - if %4% OR_LESS 0 {
         - if %3% MORE 0 {
           - if <player.health> LESS %5% {
             - adjust <player> 'health:%5%'
             }
           }
           else {
           - if <player.health> MORE %6% {
             - animate <player> animation:hurt
             - adjust <player> 'health:%6%'
             }
           }
         - wait 1s
         - while next
         }
       - if %3% MORE 0 {
         - if <player.health> LESS %5% {
           - define newHealth '<player.health.add[%3%]>'
           - adjust <player> 'health:<tern[<def[newHealth].is[MORE].than[%5%]>]:%5%||%newHealth%>'
           }
         }
         else {
         - if <player.health> MORE %6% {
           - animate <player> animation:hurt
           - define newHealth '<player.health.add[%3%]>'
           - adjust <player> 'health:<tern[<def[newHealth].is[LESS].than[%6%]>]:%6%||%newHealth%>'
           }
         }
       - wait <def[4].as_duration>
       }
 
 
 dRegions_Flag_Heal-Delay:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Heal-Delay<&4>]"
   lore:
   - <&5>The duration between heal intervals
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the time in seconds between heal intervals. Defaults to 5 seconds.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if <def[flagValue].is[LESS].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Can not specify negative time!'
       - queue clear
       }
 
 
 dRegions_Flag_Heal-Max:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Heal-Max<&4>]"
   lore:
   - <&5>Max health for heal flag.
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the max health that the heal flag will heal a player to. Defaults to 20.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if !<def[flagValue].is[MORE].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Must be a value greater than 0!'
       - queue clear
       }
 
 
 dRegions_Flag_Heal-Min:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Heal-Min<&4>]"
   lore:
   - <&5>Minimum health for heal flag
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the min health that the heal flag will heal a player to. Defaults to 0.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if <def[flagValue].is[LESS].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Can not set to a negative number!'
       - queue clear
       }
 
 
 dRegions_Flag_Feed-Amount:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Feed-Amount<&4>]"
   lore:
   - <&5>The amount to feed or starve.
   event_hook: regionEnter
   event_priority: 10
   flag_type: number
   flag_help: Set the amount to feed or starve a player while inside a region. Defaults to no effect. Positive numbers will feed players, negative numbers will starve players.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   event:
     - define feedAmount '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-amount]>'
     - if %feedAmount% != null {
       - define feedDelay '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-delay]>'
       - if %feedDelay% == null {
         - define feedDelay '5'
         }
       - define feedMax '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-max]>'
       - if %feedMax% == null {
         - define feedMax '20'
         }
       - define feedMin '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|feed-min]>'
       - if %feedMin% == null {
         - define feedMin '0'
         }
       - if <queue.exists[dRegions_Feed_<player.name>]> {
         - queue q@dRegions_Feed_<player.name> clear
         }
       - run locally feedTask delay:1t 'def:%world%|%region%|%feedAmount%|%feedDelay%|%feedMax%|%feedMin%' id:dRegions_Feed_<player.name>
       }
 
   event-global:
     - define feedAmount '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-amount]>'
     - if %feedAmount% != null {
       - define feedDelay '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-delay]>'
       - if %feedDelay% == null {
         - define feedDelay '5'
         }
       - define feedMax '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-max]>'
       - if %feedMax% == null {
         - define feedMax '20'
         }
       - define feedMin '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|feed-min]>'
       - if %feedMin% == null {
         - define feedMin '0'
         }
       - if <queue.exists[dRegions_Feed_<player.name>]> {
         - queue q@dRegions_Feed_<player.name> clear
         }
       - run locally feedTask delay:1t 'def:%world%|__global__|%feedAmount%|%feedDelay%|%feedMax%|%feedMin%' id:dRegions_Feed_<player.name>
       }
 
   feedTask:
     - while <player.is_online> {
       - define world '<player.world.name>'
       - if %world% != %1% {
         - while stop
         }
       - define regionPri 'li@'
       - foreach <player.location.cuboids.parse[notable_name].filter[starts_with[dRegions_]].parse[after[dregions_%world%_]].include[__global__]> {
         - define regionPri '%regionPri%<yaml[dRegions_%world%_regions].read[regions.%value%.priority]||0>/%value%|'
         }
       - define region '<def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]>'
       - if <def[regionPri].alphanumeric.reverse.parse[split[/].get[2]].get[1]> != %2% {
         - while stop
         }
 
       - if <player.gamemode.id> == 1 {
         - wait 1s
         - while next
         }
       - if %4% OR_LESS 0 {
         - if %3% MORE 0 {
           - if <player.food_level> LESS %5% {
             - adjust <player> 'food_level:%5%'
             - adjust <player> 'saturation:<player.food_level>'
             }
           }
           else {
           - if <player.food_level> MORE %6% {
             - animate <player> animation:hurt
             - adjust <player> 'food_level:%6%'
             - adjust <player> 'saturation:<player.food_level>'
             }
           }
         - wait 1s
         - while next
         }
       - if %3% MORE 0 {
         - if <player.food_level> LESS %5% {
           - define newFood '<player.food_level.add[%2%]>'
           - adjust <player> 'food_level:<tern[<def[newFood].is[MORE].than[%5%]>]:%5%||%newFood%>'
           - adjust <player> 'saturation:<player.food_level>'
           }
         }
         else {
         - if <player.food_level> MORE %6% {
           - define newFood '<player.food_level.add[%3%]>'
           - adjust <player> 'food_level:<tern[<def[newFood].is[LESS].than[%6%]>]:%6%||%newFood%>'
           - adjust <player> 'saturation:<player.food_level>'
           - animate <player> animation:hurt
           }
         }
       - wait <def[4].as_duration>
       }
 
 
 dRegions_Flag_Feed-Delay:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Feed-Delay<&4>]"
   lore:
   - <&5>The duration between feed intervals
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the time in seconds between feed intervals. Defaults to 5 seconds.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if <def[flagValue].is[LESS].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Can not specify negative time!'
       - queue clear
       }
 
 
 dRegions_Flag_Feed-Max:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Feed-Max<&4>]"
   lore:
   - <&5>Max health for feed flag.
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the max food level that the feed-amount flag will bring a player to. Defaults to 20.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if !<def[flagValue].is[MORE].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Must be a value greater than 0!'
       - queue clear
       }
 
 
 dRegions_Flag_Feed-Min:
   type: item
   speed: 0
   debug: false
   material: i@paper
   display name: "<&4>[<&6>Feed-Min<&4>]"
   lore:
   - <&5>Minimum food level for feed-amount flag
   flag_type: number
   flag_takeGroup: false
   flag_help: Set the min food level that the feed-amount flag will bring a player to. Defaults to 0.
   script:
     - narrate "A handy container for region flags."
     - narrate "We<&sq>ll have subscripts for various tasks."
 
   button_click:
     - narrate "This will be useful when it comes time to make the GUI for region management."
 
   command_handler:
     - if <def[flagValue].is[LESS].than[0]> {
       - run s@dRegions_Msg delay:1t 'def:<&c>Can not set to a negative number!'
       - queue clear
       }
 
 
 
 
 
 
 ################################################################################
 
 dRegions_Flags_Processors:
   type: task
   speed: 0
   debug: false
 
 #---------------------------------------
 # Region flag pre-processors
 #
 
   state-withGroup:
   # Requires each flag to build the flag object.
   # Allows for iterating over %orderedRegions% from within the flag
   # Membership is checked against the highest priority region while flag value
   # can be set in any region in %orderedRegions%
     - if <def[flagObj].split[/].get[1]> == allow {
       - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
       else {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
 
 
   state-withTarget:
     - if %flagVal% == allow {
       - if %targetList% != li@null && %targetList% != li@all && %targetList% !contains %target% {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
       else {
       - if %targetList% == li@null || %targetList% == li@all || %targetList% contains %target% {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
 
 
   state-withTarget-withGroup:
     - if <def[flagObj].split[/].get[1]> == allow {
       - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%thisRegion%|%world%|%player%]> {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       - if %targetList% != li@null && %targetList% != li@all && %targetList% !contains %target% {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
       else {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|%thisRegion%|%world%|%player%]> {
         - if %targetList% == li@null || %targetList% == li@all || %targetList% contains %target% {
           - inject %FlagScript% p:event-cleanup
           - determine cancelled
           }
         }
       }
 
 
   state-withTargetString-withGroup:
     - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
       - define region '<def[orderedRegions].get[1]>'
       - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag%]>'
       }
       else {
       - foreach %orderedRegions% {
         - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
         - define region '%value%'
         - if %flagObj% != null {
           - foreach stop
           }
         }
       }
     - if %flagObj% == null {
       - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
       }
     - if %flagObj% != none {
       - if <def[flagObj].split[/].get[1]> == allow {
         - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
           - inject %FlagScript% p:event-cleanup
           - determine cancelled
           }
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
         - if ( %targetList% != li@null ) && ( %targetList% != li@all ) {
           - foreach %targetList% {
             - if <def[target].starts_with[%value%]> {
               - inject %FlagScript% p:event-cleanup
               - determine cancelled
               }
             }
           }
         }
         else {
         - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|<def[orderedRegions].get[1]>|%world%|%player%]> {
           - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
           - if ( %targetList% == li@null ) || ( %targetList% == li@all ) {
             - inject %FlagScript% p:event-cleanup
             - determine cancelled
             }
           - foreach %targetList% {
             - if <def[target].starts_with[%value%]> {
               - inject %FlagScript% p:event-cleanup
               - determine cancelled
               }
             }
           }
         }
       }
 
 
 
 ##############################
 # Abstract methods
 #
 #  state-withTarget:
 #    - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
 #      - define orderedRegions '<def[orderedRegions].get[1].as_list>'
 #      }
 #    - foreach %orderedRegions% {
 #      - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
 #      - if %flagVal% == null {
 #        - foreach next
 #        }
 #      - define region '%value%'
 #      - foreach stop
 #      }
 #    - inject locally state-process-WithTargetNoGroup_%flagVal%
 #    - queue clear
 
 
 #  state-withGroup:
 #    - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
 #      - define orderedRegions '<def[orderedRegions].get[1].as_list>'
 #      }
 #    - foreach %orderedRegions% {
 #      - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
 #      - if %flagObj% == null {
 #        - foreach next
 #        }
 #      - define region '%value%'
 #      - foreach stop
 #      }
 #    - inject locally state-process-WithGroup_<def[flagObj].split[/].get[1]>
 #    - queue clear
 
 
 #  state-withTarget-withGroup:
 #    - if <def[FlagScript].yaml_key[region_highestOnly]||false> {
 #      - define orderedRegions '<def[orderedRegions].get[1].as_list>'
 #      }
 #    - foreach %orderedRegions% {
 #      - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|%value%|%flag%]>'
 #      - if %flagObj% == null {
 #        - foreach next
 #        }
 #      - define region '%value%'
 #      - foreach stop
 #      }
 #    - inject locally state-process-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
 #    - queue clear
 
 
 #---------------------------------------
 # Global flag pre-processors
 #
   boolean-Global:
     - define flagVal '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]||null>'
     - if %flagVal% == null {
       - define flagVal '<def[FlagScript].yaml_key[flag_globalDefault]||true>'
       }
     - if !%flagVal% {
       - inject %FlagScript% p:event-cleanup
       - determine cancelled
       }
 
   state-withGroup-Global:
     - if <def[flagObj].split[/].get[1]> == allow {
       - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
       else {
       - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
         - inject %FlagScript% p:event-cleanup
         - determine cancelled
         }
       }
 
 
   state-withTargetString-withGroup-Global:
     - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
     - if %flagObj% == null {
       - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
       }
     - if %flagObj% != none {
       - if <def[flagObj].split[/].get[1]> == allow {
         - if !<proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
           - inject %FlagScript% p:event-cleanup
           - determine cancelled
           }
         - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
         - if ( %targetList% != li@null ) && ( %targetList% != li@all ) {
           - foreach %targetList% {
             - if <def[target].starts_with[%value%]> {
               - inject %FlagScript% p:event-cleanup
               - determine cancelled
               }
             }
           }
         }
         else {
         - if <proc[dRegions_PlayerMatchRegionGroup].context[<def[flagObj].split[/].get[2]||all>|__global__|%world%|%player%]> {
           - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[<def[delimiter]||, >].with[|].as_list>'
           - if ( %targetList% == li@null ) || ( %targetList% == li@all ) {
             - inject %FlagScript% p:event-cleanup
             - determine cancelled
             }
           - foreach %targetList% {
             - if <def[target].starts_with[%value%]> {
               - inject %FlagScript% p:event-cleanup
               - determine cancelled
               }
             }
           }
         }
       }
 
 
 ##############################
 # Abstract methods
 #
 #  state-withGroup-Global:
 #    - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
 #    - inject locally state-process-Global-WithGroup_<def[flagObj].split[/].get[1]>
 #    - queue clear
 
 
 #  state-withTarget-Global:
 #    - inject locally state-process-Global-WithTargetNoGroup_<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>
 #    - queue clear
 
 
 #  state-withTarget-withGroup-Global:
 #    - define flagObj '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag%]>'
 #    - inject locally state-process-Global-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
 #    - queue clear
 
 #-------------------
 # Global WithGroup Flag Processors
 #
 #  state-process-Global-WithGroup_null:
 #    - define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
 #    - inject locally state-process-Global-WithGroup_<def[flagObj].split[/].get[1]>
 
 #  state-process-Global-WithGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-Global-WithGroup_allow:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-Global-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%].not>
 
 #  state-process-Global-WithGroup_deny:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-Global-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
 
 #  state-process-Global-WithGroup_deny-true:
 #    - inject %FlagScript% p:event-cleanup
 #    - determine cancelled
 
 
 #-------------------
 # Global WithTargetWithGroup Flag Processors
 #
 #  state-process-Global-WithTargetWithGroup_null:
 #    - define flagObj '<def[FlagScript].yaml_key[flag_globalDefault]||none>'
 #    - inject locally state-process-Global-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
 
 #  state-process-Global-WithTargetWithGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-Global-WithTargetWithGroup_allow:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-Global-WithTargetWithGroup_allow-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
 
 #  state-process-Global-WithTargetWithGroup_allow-true:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - queue clear
 #      }
 #    - if %targetList% != li@all {
 #      - if %targetList% !contains %target% {
 #        - inject %FlagScript% p:event-cleanup
 #        - determine cancelled
 #        }
 #      }
 
 #  state-process-Global-WithTargetWithGroup_allow-false:
 #    - inject %FlagScript% p:event-cleanup
 #    - determine cancelled
 
 #  state-process-Global-WithTargetWithGroup_deny:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-Global-WithTargetWithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|__global__|%world%|%player%]>
 
 #  state-process-Global-WithTargetWithGroup_deny-true:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% == li@all {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% contains %target% {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 
 #-------------------
 # Global WithTargetNoGroup Flag Processors
 #
 #  state-process-Global-WithTargetNoGroup_null:
 #    - inject locally state-process-Global-WithTargetNoGroup_<def[FlagScript].yaml_key[flag_globalDefalut]||none>
 
 #  state-process-Global-WithTargetNoGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-Global-WithTargetNoGroup_allow:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == 'li@null' {
 #      - queue clear
 #      }
 #    - if %targetList% != li@all {
 #      - if %targetList% !contains %target% {
 #        - inject %FlagScript% p:event-cleanup
 #        - determine cancelled
 #        }
 #      }
 
 #  state-process-Global-WithTargetNoGroup_deny:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|__global__|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% == li@all {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% contains %target% {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 
 
 #-------------------
 # Region WithGroup Flag Processors
 #
 #  state-process-WithGroup_null:
 #    - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
 #    - inject locally state-process-WithGroup_<def[flagObj].split[/].get[1]>
 
 #  state-process-WithGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-WithGroup_allow:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%].not>
 
 #  state-process-WithGroup_deny:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-WithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
 
 #  state-process-WithGroup_deny-true:
 #    - inject %FlagScript% p:event-cleanup
 #    - determine cancelled
 
 
 #-------------------
 # Region WithTargetWithGroup Flag Processors
 #
 #  state-process-WithTargetWithGroup_null:
 #    - define flagObj '<def[FlagScript].yaml_key[flag_defaultValue]||none>'
 #    - inject locally state-process-WithTargetWithGroup_<def[flagObj].split[/].get[1]>
 
 #  state-process-WithTargetWithGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-WithTargetWithGroup_allow:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-WithTargetWithGroup_allow-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
 
 #  state-process-WithTargetWithGroup_allow-true:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - queue clear
 #      }
 #    - if %targetList% != li@all {
 #      - if %targetList% !contains %target% {
 #        - inject %FlagScript% p:event-cleanup
 #        - determine cancelled
 #        }
 #      }
 
 #  state-process-WithTargetWithGroup_allow-false:
 #    - inject %FlagScript% p:event-cleanup
 #    - determine cancelled
 
 #  state-process-WithTargetWithGroup_deny:
 #    - define group '<def[flagObj].split[/].get[2]||all>'
 #    - inject locally state-process-WithTargetWithGroup_deny-<proc[dRegions_PlayerMatchRegionGroup].context[%group%|<def[orderedRegions].get[1]>|%world%|%player%]>
 
 #  state-process-WithTargetWithGroup_deny-true:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% == li@all {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% contains %target% {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 
 #-------------------
 # Region WithTargetNoGroup Flag Processors
 #
 #  state-process-WithTargetNoGroup_null:
 #    - inject locally state-process-WithTargetNoGroup_<def[FlagScript].yaml_key[flag_defaultValue]||none>
 
 #  state-process-WithTargetNoGroup_none:
 #    - foreach next
 #    - queue clear
 
 #  state-process-WithTargetNoGroup_allow:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == 'li@null' {
 #      - queue clear
 #      }
 #    - if %targetList% != li@all {
 #      - if %targetList% !contains %target% {
 #        - inject %FlagScript% p:event-cleanup
 #        - determine cancelled
 #        }
 #      }
 
 #  state-process-WithTargetNoGroup_deny:
 #    - define targetList '<proc[dRegions_GetInheritedFlag].context[%world%|%region%|%flag-targetList%].replace[, ].with[|].as_list>'
 #    - if %targetList% == li@null {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% == li@all {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 #    - if %targetList% contains %target% {
 #      - inject %FlagScript% p:event-cleanup
 #      - determine cancelled
 #      }
 
 
 
 #-------------------------------------------------------------------------------
 
 
 dRegions_Flags_CommandProcessors:
   type: task
   speed: 0
   debug: false
 
   command_verifiedList:
     - if <def[flagValue].is[==].to[null]||false> {
       - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
       - queue clear
       }
       else {
       - define entries '<def[flagValue].split[ ].get[2].to[<def[flagValue].split[ ].size>].parse[to_lowercase].deduplicate||li@>'
       - if <def[entries].get[1].is[==].to[all]> {
         - if '<def[flagValue].split[ ].get[1].is[==].to[-a]||false>' {
           - yaml set 'regions.%region%.flags.%flag%:all' 'id:dRegions_%world%_regions'
           - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
           - run s@dRegions_Msg delay:1t 'def:<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%'
           - queue clear
           }
         - if '<def[flagValue].split[ ].get[1].is[==].to[-r]||false>' {
           - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
           - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
           - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
           - queue clear
           }
         }
       - foreach %entries% {
         - if <parse:<s@dRegions_Flag_%Flag%.yaml_key[command_verifyEntry]||false>> {
           - define entries '<def[entries].exclude[%value%]||li@>'
           - run  s@dRegions_Msg 'def:<&c><&o>%value% is not a valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>!'
           }
         }
       - if <def[entries].is_empty||true> {
         - run  s@dRegions_Msg 'def:<&c><&o>No valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>s specified!'
         - define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
         - foreach <def[lines]> {
           - run s@dRegions_Msg delay:1t 'def:<&c><def[value]>'
           }
         - queue clear
         }
 
       - define currentEntries '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%].replace[, ].with[|].as_list||li@>'
       - if '<def[flagValue].split[ ].get[1].is[==].to[-a]||false>' {
         - define flagValue '<def[currentEntries].include[<def[entries].replace[li@]>].deduplicate||li@>'
         }
       - if '<def[flagValue].split[ ].get[1].is[==].to[-r]||false>' {
         - define flagValue '<def[currentEntries].exclude[<def[entries].replace[li@]>].deduplicate||li@>'
         }
       - if <def[flagValue].is_empty||true> {
         - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
         - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
         - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
         - queue clear
         }
       - define flagValue '<def[flagValue].comma_separated>'
       }
 
 
   command_stringList:
     - if <def[flagValue].is[==].to[null]||false> {
       - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
       - queue clear
       }
     - define action '<def[flagValue].split[ ].get[1]>'
     - define string '<def[flagValue].after[<def[action]>]>'
 
     - if '<def[string].is[==].to[all]>' {
       - if <def[action].is[==].to[-a]||false> {
         - yaml set 'regions.%region%.flags.%flag%:all' 'id:dRegions_%world%_regions'
         - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
         - run s@dRegions_Msg delay:1t 'def:<&f><&o>%region%<&7><&o> set %flag% flag to <&f><&o>%flagValue%'
         - queue clear
         }
       - if <def[action].is[==].to[-r]||false> {
         - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
         - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
         - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
         - queue clear
         }
       }
     - if <def[string].length.is[==].to[0]||true> {
       - run  s@dRegions_Msg 'def:<&c><&o>No valid <s@dRegions_Flag_%Flag%.yaml_key[command_entryType]>s specified!'
       - define lines '<proc[dRegions_LineWrap].context[<s@dRegions_Flag_%Flag%.yaml_key[flag_help]||<&c>%flag% flag requires a %type% value!>|45]>'
       - foreach <def[lines]> {
         - run s@dRegions_Msg delay:1t 'def:<&c><def[value]>'
         }
       - queue clear
       }
 
     - define currentEntries '<yaml[dRegions_%world%_regions].read[regions.%region%.flags.%flag%].replace[ ; ].with[|].as_list||li@>'
     - if '<def[action].is[==].to[-a]||false>' {
       - define flagValue '<def[currentEntries].include[<def[string]>].deduplicate||li@>'
       }
     - if '<def[action].is[==].to[-r]||false>' {
       - define flagValue '<def[currentEntries].exclude[<def[string]>].deduplicate||li@>'
       }
     - if <def[flagValue].is_empty||true> {
       - yaml set 'regions.%region%.flags.%flag%:!' 'id:dRegions_%world%_regions'
       - yaml 'savefile:dRegions/worlds/%world%/regions.yml' 'id:dRegions_%world%_regions'
       - run s@dRegions_Msg delay:1t 'def:<&c>Cleared %flag% list for region %region%'
       - queue clear
       }
     - define flagValue '<def[flagValue].replace[|].with[ ; ].replace[li@]>'
 
 
 #