from cardboard import types
from cardboard.ability import (
    AbilityNotImplemented, spell, activated, triggered, static
)
from cardboard.cards import card, common, keywords, match


@card("Advance Scout")
def advance_scout(card, abilities):

    def advance_scout():
        return AbilityNotImplemented

    def advance_scout():
        return AbilityNotImplemented

    return advance_scout, advance_scout,


@card("Fevered Convulsions")
def fevered_convulsions(card, abilities):

    def fevered_convulsions():
        return AbilityNotImplemented

    return fevered_convulsions,


@card("Earthcraft")
def earthcraft(card, abilities):

    def earthcraft():
        return AbilityNotImplemented

    return earthcraft,


@card("Pearl Medallion")
def pearl_medallion(card, abilities):

    def pearl_medallion():
        return AbilityNotImplemented

    return pearl_medallion,


@card("Ruby Medallion")
def ruby_medallion(card, abilities):

    def ruby_medallion():
        return AbilityNotImplemented

    return ruby_medallion,


@card("Skyshroud Troll")
def skyshroud_troll(card, abilities):

    def skyshroud_troll():
        return AbilityNotImplemented

    return skyshroud_troll,


@card("Fireslinger")
def fireslinger(card, abilities):

    def fireslinger():
        return AbilityNotImplemented

    return fireslinger,


@card("Legerdemain")
def legerdemain(card, abilities):

    def legerdemain():
        return AbilityNotImplemented

    return legerdemain,


@card("Reap")
def reap(card, abilities):

    def reap():
        return AbilityNotImplemented

    return reap,


@card("Auratog")
def auratog(card, abilities):

    def auratog():
        return AbilityNotImplemented

    return auratog,


@card("Field of Souls")
def field_of_souls(card, abilities):

    def field_of_souls():
        return AbilityNotImplemented

    return field_of_souls,


@card("Heartwood Giant")
def heartwood_giant(card, abilities):

    def heartwood_giant():
        return AbilityNotImplemented

    return heartwood_giant,


@card("Rootwater Diver")
def rootwater_diver(card, abilities):

    def rootwater_diver():
        return AbilityNotImplemented

    return rootwater_diver,


@card("Bounty Hunter")
def bounty_hunter(card, abilities):

    def bounty_hunter():
        return AbilityNotImplemented

    def bounty_hunter():
        return AbilityNotImplemented

    return bounty_hunter, bounty_hunter,


@card("Abandon Hope")
def abandon_hope(card, abilities):

    def abandon_hope():
        return AbilityNotImplemented

    def abandon_hope():
        return AbilityNotImplemented

    return abandon_hope, abandon_hope,


@card("Goblin Bombardment")
def goblin_bombardment(card, abilities):

    def goblin_bombardment():
        return AbilityNotImplemented

    return goblin_bombardment,


@card("Sarcomancy")
def sarcomancy(card, abilities):

    def sarcomancy():
        return AbilityNotImplemented

    def sarcomancy():
        return AbilityNotImplemented

    return sarcomancy, sarcomancy,


@card("Searing Touch")
def searing_touch(card, abilities):

    def searing_touch():
        return AbilityNotImplemented

    def searing_touch():
        return AbilityNotImplemented

    return searing_touch, searing_touch,


@card("Broken Fall")
def broken_fall(card, abilities):

    def broken_fall():
        return AbilityNotImplemented

    return broken_fall,


@card("Coffin Queen")
def coffin_queen(card, abilities):

    def coffin_queen():
        return AbilityNotImplemented

    def coffin_queen():
        return AbilityNotImplemented

    return coffin_queen, coffin_queen,


@card("Oracle en-Vec")
def oracle_envec(card, abilities):

    def oracle_envec():
        return AbilityNotImplemented

    return oracle_envec,


@card("Emmessi Tome")
def emmessi_tome(card, abilities):

    def emmessi_tome():
        return AbilityNotImplemented

    return emmessi_tome,


@card("Booby Trap")
def booby_trap(card, abilities):

    def booby_trap():
        return AbilityNotImplemented

    def booby_trap():
        return AbilityNotImplemented

    def booby_trap():
        return AbilityNotImplemented

    return booby_trap, booby_trap, booby_trap,


@card("Elite Javelineer")
def elite_javelineer(card, abilities):

    def elite_javelineer():
        return AbilityNotImplemented

    return elite_javelineer,


@card("Minion of the Wastes")
def minion_of_the_wastes(card, abilities):

    def minion_of_the_wastes():
        return AbilityNotImplemented

    def minion_of_the_wastes():
        return AbilityNotImplemented

    def minion_of_the_wastes():
        return AbilityNotImplemented

    return minion_of_the_wastes, minion_of_the_wastes, minion_of_the_wastes,


@card("Giant Crab")
def giant_crab(card, abilities):

    def giant_crab():
        return AbilityNotImplemented

    return giant_crab,


@card("Dauthi Mindripper")
def dauthi_mindripper(card, abilities):

    def dauthi_mindripper():
        return AbilityNotImplemented

    def dauthi_mindripper():
        return AbilityNotImplemented

    return dauthi_mindripper, dauthi_mindripper,


@card("Mounted Archers")
def mounted_archers(card, abilities):

    def mounted_archers():
        return AbilityNotImplemented

    def mounted_archers():
        return AbilityNotImplemented

    return mounted_archers, mounted_archers,


@card("Chaotic Goo")
def chaotic_goo(card, abilities):

    def chaotic_goo():
        return AbilityNotImplemented

    def chaotic_goo():
        return AbilityNotImplemented

    return chaotic_goo, chaotic_goo,


@card("Eladamri, Lord of Leaves")
def eladamri_lord_of_leaves(card, abilities):

    def eladamri_lord_of_leaves():
        return AbilityNotImplemented

    def eladamri_lord_of_leaves():
        return AbilityNotImplemented

    return eladamri_lord_of_leaves, eladamri_lord_of_leaves,


@card("Leeching Licid")
def leeching_licid(card, abilities):

    def leeching_licid():
        return AbilityNotImplemented

    def leeching_licid():
        return AbilityNotImplemented

    return leeching_licid, leeching_licid,


@card("Canyon Drake")
def canyon_drake(card, abilities):

    def canyon_drake():
        return AbilityNotImplemented

    def canyon_drake():
        return AbilityNotImplemented

    return canyon_drake, canyon_drake,


@card("Humility")
def humility(card, abilities):

    def humility():
        return AbilityNotImplemented

    return humility,


@card("Rootbreaker Wurm")
def rootbreaker_wurm(card, abilities):

    def rootbreaker_wurm():
        return AbilityNotImplemented

    return rootbreaker_wurm,


@card("Spike Drone")
def spike_drone(card, abilities):

    def spike_drone():
        return AbilityNotImplemented

    def spike_drone():
        return AbilityNotImplemented

    return spike_drone, spike_drone,


@card("Watchdog")
def watchdog(card, abilities):

    def watchdog():
        return AbilityNotImplemented

    def watchdog():
        return AbilityNotImplemented

    return watchdog, watchdog,


@card("Sacred Guide")
def sacred_guide(card, abilities):

    def sacred_guide():
        return AbilityNotImplemented

    return sacred_guide,


@card("Firefly")
def firefly(card, abilities):

    def firefly():
        return AbilityNotImplemented

    def firefly():
        return AbilityNotImplemented

    return firefly, firefly,


@card("Circle of Protection: Shadow")
def circle_of_protection_shadow(card, abilities):

    def circle_of_protection_shadow():
        return AbilityNotImplemented

    return circle_of_protection_shadow,


@card("Wasteland")
def wasteland(card, abilities):

    def wasteland():
        return AbilityNotImplemented

    def wasteland():
        return AbilityNotImplemented

    return wasteland, wasteland,


@card("Flickering Ward")
def flickering_ward(card, abilities):

    def flickering_ward():
        return AbilityNotImplemented

    def flickering_ward():
        return AbilityNotImplemented

    def flickering_ward():
        return AbilityNotImplemented

    def flickering_ward():
        return AbilityNotImplemented

    return flickering_ward, flickering_ward, flickering_ward, flickering_ward,


@card("Flowstone Sculpture")
def flowstone_sculpture(card, abilities):

    def flowstone_sculpture():
        return AbilityNotImplemented

    return flowstone_sculpture,


@card("Echo Chamber")
def echo_chamber(card, abilities):

    def echo_chamber():
        return AbilityNotImplemented

    return echo_chamber,


@card("Altar of Dementia")
def altar_of_dementia(card, abilities):

    def altar_of_dementia():
        return AbilityNotImplemented

    return altar_of_dementia,


@card("Energizer")
def energizer(card, abilities):

    def energizer():
        return AbilityNotImplemented

    return energizer,


@card("Essence Bottle")
def essence_bottle(card, abilities):

    def essence_bottle():
        return AbilityNotImplemented

    def essence_bottle():
        return AbilityNotImplemented

    return essence_bottle, essence_bottle,


@card("Caldera Lake")
def caldera_lake(card, abilities):

    def caldera_lake():
        return AbilityNotImplemented

    def caldera_lake():
        return AbilityNotImplemented

    def caldera_lake():
        return AbilityNotImplemented

    return caldera_lake, caldera_lake, caldera_lake,


@card("Heartwood Dryad")
def heartwood_dryad(card, abilities):

    def heartwood_dryad():
        return AbilityNotImplemented

    return heartwood_dryad,


@card("Death Pits of Rath")
def death_pits_of_rath(card, abilities):

    def death_pits_of_rath():
        return AbilityNotImplemented

    return death_pits_of_rath,


@card("Spinal Graft")
def spinal_graft(card, abilities):

    def spinal_graft():
        return AbilityNotImplemented

    def spinal_graft():
        return AbilityNotImplemented

    def spinal_graft():
        return AbilityNotImplemented

    return spinal_graft, spinal_graft, spinal_graft,


@card("Bottle Gnomes")
def bottle_gnomes(card, abilities):

    def bottle_gnomes():
        return AbilityNotImplemented

    return bottle_gnomes,


@card("Mogg Hollows")
def mogg_hollows(card, abilities):

    def mogg_hollows():
        return AbilityNotImplemented

    def mogg_hollows():
        return AbilityNotImplemented

    return mogg_hollows, mogg_hollows,


@card("Propaganda")
def propaganda(card, abilities):

    def propaganda():
        return AbilityNotImplemented

    return propaganda,


@card("Cinder Marsh")
def cinder_marsh(card, abilities):

    def cinder_marsh():
        return AbilityNotImplemented

    def cinder_marsh():
        return AbilityNotImplemented

    return cinder_marsh, cinder_marsh,


@card("Manakin")
def manakin(card, abilities):

    def manakin():
        return AbilityNotImplemented

    return manakin,


@card("Frog Tongue")
def frog_tongue(card, abilities):

    def frog_tongue():
        return AbilityNotImplemented

    def frog_tongue():
        return AbilityNotImplemented

    def frog_tongue():
        return AbilityNotImplemented

    return frog_tongue, frog_tongue, frog_tongue,


@card("Renegade Warlord")
def renegade_warlord(card, abilities):

    def renegade_warlord():
        return AbilityNotImplemented

    def renegade_warlord():
        return AbilityNotImplemented

    return renegade_warlord, renegade_warlord,


@card("Stun")
def stun(card, abilities):

    def stun():
        return AbilityNotImplemented

    def stun():
        return AbilityNotImplemented

    return stun, stun,


@card("Clergy en-Vec")
def clergy_envec(card, abilities):

    def clergy_envec():
        return AbilityNotImplemented

    return clergy_envec,


@card("Telethopter")
def telethopter(card, abilities):

    def telethopter():
        return AbilityNotImplemented

    return telethopter,


@card("Enraging Licid")
def enraging_licid(card, abilities):

    def enraging_licid():
        return AbilityNotImplemented

    def enraging_licid():
        return AbilityNotImplemented

    return enraging_licid, enraging_licid,


@card("Rootwater Depths")
def rootwater_depths(card, abilities):

    def rootwater_depths():
        return AbilityNotImplemented

    def rootwater_depths():
        return AbilityNotImplemented

    return rootwater_depths, rootwater_depths,


@card("Cloudchaser Eagle")
def cloudchaser_eagle(card, abilities):

    def cloudchaser_eagle():
        return AbilityNotImplemented

    def cloudchaser_eagle():
        return AbilityNotImplemented

    return cloudchaser_eagle, cloudchaser_eagle,


@card("Stinging Licid")
def stinging_licid(card, abilities):

    def stinging_licid():
        return AbilityNotImplemented

    def stinging_licid():
        return AbilityNotImplemented

    return stinging_licid, stinging_licid,


@card("Mawcor")
def mawcor(card, abilities):

    def mawcor():
        return AbilityNotImplemented

    def mawcor():
        return AbilityNotImplemented

    return mawcor, mawcor,


@card("Screeching Harpy")
def screeching_harpy(card, abilities):

    def screeching_harpy():
        return AbilityNotImplemented

    def screeching_harpy():
        return AbilityNotImplemented

    return screeching_harpy, screeching_harpy,


@card("Overrun")
def overrun(card, abilities):

    def overrun():
        return AbilityNotImplemented

    return overrun,


@card("Carrionette")
def carrionette(card, abilities):

    def carrionette():
        return AbilityNotImplemented

    return carrionette,


@card("Orim's Prayer")
def orims_prayer(card, abilities):

    def orims_prayer():
        return AbilityNotImplemented

    return orims_prayer,


@card("Insight")
def insight(card, abilities):

    def insight():
        return AbilityNotImplemented

    return insight,


@card("Boil")
def boil(card, abilities):

    def boil():
        return AbilityNotImplemented

    return boil,


@card("Shimmering Wings")
def shimmering_wings(card, abilities):

    def shimmering_wings():
        return AbilityNotImplemented

    def shimmering_wings():
        return AbilityNotImplemented

    def shimmering_wings():
        return AbilityNotImplemented

    return shimmering_wings, shimmering_wings, shimmering_wings,


@card("Mindwhip Sliver")
def mindwhip_sliver(card, abilities):

    def mindwhip_sliver():
        return AbilityNotImplemented

    return mindwhip_sliver,


@card("Fighting Drake")
def fighting_drake(card, abilities):

    def fighting_drake():
        return AbilityNotImplemented

    return fighting_drake,


@card("Eladamri's Vineyard")
def eladamris_vineyard(card, abilities):

    def eladamris_vineyard():
        return AbilityNotImplemented

    return eladamris_vineyard,


@card("Reflecting Pool")
def reflecting_pool(card, abilities):

    def reflecting_pool():
        return AbilityNotImplemented

    return reflecting_pool,


@card("Dismiss")
def dismiss(card, abilities):

    def dismiss():
        return AbilityNotImplemented

    def dismiss():
        return AbilityNotImplemented

    return dismiss, dismiss,


@card("Opportunist")
def opportunist(card, abilities):

    def opportunist():
        return AbilityNotImplemented

    return opportunist,


@card("Extinction")
def extinction(card, abilities):

    def extinction():
        return AbilityNotImplemented

    return extinction,


@card("Skyshroud Vampire")
def skyshroud_vampire(card, abilities):

    def skyshroud_vampire():
        return AbilityNotImplemented

    def skyshroud_vampire():
        return AbilityNotImplemented

    return skyshroud_vampire, skyshroud_vampire,


@card("Elvish Fury")
def elvish_fury(card, abilities):

    def elvish_fury():
        return AbilityNotImplemented

    def elvish_fury():
        return AbilityNotImplemented

    return elvish_fury, elvish_fury,


@card("Tooth and Claw")
def tooth_and_claw(card, abilities):

    def tooth_and_claw():
        return AbilityNotImplemented

    return tooth_and_claw,


@card("Commander Greven il-Vec")
def commander_greven_ilvec(card, abilities):

    def commander_greven_ilvec():
        return AbilityNotImplemented

    def commander_greven_ilvec():
        return AbilityNotImplemented

    return commander_greven_ilvec, commander_greven_ilvec,


@card("Ghost Town")
def ghost_town(card, abilities):

    def ghost_town():
        return AbilityNotImplemented

    def ghost_town():
        return AbilityNotImplemented

    return ghost_town, ghost_town,


@card("Blood Frenzy")
def blood_frenzy(card, abilities):

    def blood_frenzy():
        return AbilityNotImplemented

    def blood_frenzy():
        return AbilityNotImplemented

    return blood_frenzy, blood_frenzy,


@card("Flowstone Wyvern")
def flowstone_wyvern(card, abilities):

    def flowstone_wyvern():
        return AbilityNotImplemented

    def flowstone_wyvern():
        return AbilityNotImplemented

    return flowstone_wyvern, flowstone_wyvern,


@card("Deadshot")
def deadshot(card, abilities):

    def deadshot():
        return AbilityNotImplemented

    return deadshot,


@card("Ancient Tomb")
def ancient_tomb(card, abilities):

    def ancient_tomb():
        return AbilityNotImplemented

    return ancient_tomb,


@card("Salt Flats")
def salt_flats(card, abilities):

    def salt_flats():
        return AbilityNotImplemented

    def salt_flats():
        return AbilityNotImplemented

    def salt_flats():
        return AbilityNotImplemented

    return salt_flats, salt_flats, salt_flats,


@card("Crazed Armodon")
def crazed_armodon(card, abilities):

    def crazed_armodon():
        return AbilityNotImplemented

    return crazed_armodon,


@card("Fugitive Druid")
def fugitive_druid(card, abilities):

    def fugitive_druid():
        return AbilityNotImplemented

    return fugitive_druid,


@card("Unstable Shapeshifter")
def unstable_shapeshifter(card, abilities):

    def unstable_shapeshifter():
        return AbilityNotImplemented

    return unstable_shapeshifter,


@card("Mongrel Pack")
def mongrel_pack(card, abilities):

    def mongrel_pack():
        return AbilityNotImplemented

    return mongrel_pack,


@card("Jinxed Idol")
def jinxed_idol(card, abilities):

    def jinxed_idol():
        return AbilityNotImplemented

    def jinxed_idol():
        return AbilityNotImplemented

    return jinxed_idol, jinxed_idol,


@card("Endless Scream")
def endless_scream(card, abilities):

    def endless_scream():
        return AbilityNotImplemented

    def endless_scream():
        return AbilityNotImplemented

    def endless_scream():
        return AbilityNotImplemented

    return endless_scream, endless_scream, endless_scream,


@card("Winged Sliver")
def winged_sliver(card, abilities):

    def winged_sliver():
        return AbilityNotImplemented

    return winged_sliver,


@card("Orim, Samite Healer")
def orim_samite_healer(card, abilities):

    def orim_samite_healer():
        return AbilityNotImplemented

    return orim_samite_healer,


@card("Jackal Pup")
def jackal_pup(card, abilities):

    def jackal_pup():
        return AbilityNotImplemented

    return jackal_pup,


@card("Dauthi Marauder")
def dauthi_marauder(card, abilities):

    def dauthi_marauder():
        return AbilityNotImplemented

    return dauthi_marauder,


@card("Pegasus Refuge")
def pegasus_refuge(card, abilities):

    def pegasus_refuge():
        return AbilityNotImplemented

    return pegasus_refuge,


@card("Dauthi Mercenary")
def dauthi_mercenary(card, abilities):

    def dauthi_mercenary():
        return AbilityNotImplemented

    def dauthi_mercenary():
        return AbilityNotImplemented

    return dauthi_mercenary, dauthi_mercenary,


@card("Servant of Volrath")
def servant_of_volrath(card, abilities):

    def servant_of_volrath():
        return AbilityNotImplemented

    return servant_of_volrath,


@card("Soltari Monk")
def soltari_monk(card, abilities):

    def soltari_monk():
        return AbilityNotImplemented

    def soltari_monk():
        return AbilityNotImplemented

    return soltari_monk, soltari_monk,


@card("Elven Warhounds")
def elven_warhounds(card, abilities):

    def elven_warhounds():
        return AbilityNotImplemented

    return elven_warhounds,


@card("Mana Severance")
def mana_severance(card, abilities):

    def mana_severance():
        return AbilityNotImplemented

    return mana_severance,


@card("Quickening Licid")
def quickening_licid(card, abilities):

    def quickening_licid():
        return AbilityNotImplemented

    def quickening_licid():
        return AbilityNotImplemented

    return quickening_licid, quickening_licid,


@card("Cold Storage")
def cold_storage(card, abilities):

    def cold_storage():
        return AbilityNotImplemented

    def cold_storage():
        return AbilityNotImplemented

    return cold_storage, cold_storage,


@card("Starke of Rath")
def starke_of_rath(card, abilities):

    def starke_of_rath():
        return AbilityNotImplemented

    return starke_of_rath,


@card("Emerald Medallion")
def emerald_medallion(card, abilities):

    def emerald_medallion():
        return AbilityNotImplemented

    return emerald_medallion,


@card("Kindle")
def kindle(card, abilities):

    def kindle():
        return AbilityNotImplemented

    return kindle,


@card("Root Maze")
def root_maze(card, abilities):

    def root_maze():
        return AbilityNotImplemented

    return root_maze,


@card("Ancient Runes")
def ancient_runes(card, abilities):

    def ancient_runes():
        return AbilityNotImplemented

    return ancient_runes,


@card("Rats of Rath")
def rats_of_rath(card, abilities):

    def rats_of_rath():
        return AbilityNotImplemented

    return rats_of_rath,


@card("Choke")
def choke(card, abilities):

    def choke():
        return AbilityNotImplemented

    return choke,


@card("Skyshroud Forest")
def skyshroud_forest(card, abilities):

    def skyshroud_forest():
        return AbilityNotImplemented

    def skyshroud_forest():
        return AbilityNotImplemented

    def skyshroud_forest():
        return AbilityNotImplemented

    return skyshroud_forest, skyshroud_forest, skyshroud_forest,


@card("Storm Front")
def storm_front(card, abilities):

    def storm_front():
        return AbilityNotImplemented

    return storm_front,


@card("Stalking Stones")
def stalking_stones(card, abilities):

    def stalking_stones():
        return AbilityNotImplemented

    def stalking_stones():
        return AbilityNotImplemented

    return stalking_stones, stalking_stones,


@card("Wall of Diffusion")
def wall_of_diffusion(card, abilities):

    def wall_of_diffusion():
        return AbilityNotImplemented

    def wall_of_diffusion():
        return AbilityNotImplemented

    return wall_of_diffusion, wall_of_diffusion,


@card("Twitch")
def twitch(card, abilities):

    def twitch():
        return AbilityNotImplemented

    def twitch():
        return AbilityNotImplemented

    return twitch, twitch,


@card("Muscle Sliver")
def muscle_sliver(card, abilities):

    def muscle_sliver():
        return AbilityNotImplemented

    return muscle_sliver,


@card("Flowstone Salamander")
def flowstone_salamander(card, abilities):

    def flowstone_salamander():
        return AbilityNotImplemented

    return flowstone_salamander,


@card("Serene Offering")
def serene_offering(card, abilities):

    def serene_offering():
        return AbilityNotImplemented

    return serene_offering,


@card("Chill")
def chill(card, abilities):

    def chill():
        return AbilityNotImplemented

    return chill,


@card("Lightning Elemental")
def lightning_elemental(card, abilities):

    def lightning_elemental():
        return AbilityNotImplemented

    return lightning_elemental,


@card("Heart Sliver")
def heart_sliver(card, abilities):

    def heart_sliver():
        return AbilityNotImplemented

    return heart_sliver,


@card("Worthy Cause")
def worthy_cause(card, abilities):

    def worthy_cause():
        return AbilityNotImplemented

    def worthy_cause():
        return AbilityNotImplemented

    def worthy_cause():
        return AbilityNotImplemented

    return worthy_cause, worthy_cause, worthy_cause,


@card("Harrow")
def harrow(card, abilities):

    def harrow():
        return AbilityNotImplemented

    def harrow():
        return AbilityNotImplemented

    return harrow, harrow,


@card("Thalakos Mistfolk")
def thalakos_mistfolk(card, abilities):

    def thalakos_mistfolk():
        return AbilityNotImplemented

    def thalakos_mistfolk():
        return AbilityNotImplemented

    return thalakos_mistfolk, thalakos_mistfolk,


@card("Barbed Sliver")
def barbed_sliver(card, abilities):

    def barbed_sliver():
        return AbilityNotImplemented

    return barbed_sliver,


@card("Flailing Drake")
def flailing_drake(card, abilities):

    def flailing_drake():
        return AbilityNotImplemented

    def flailing_drake():
        return AbilityNotImplemented

    return flailing_drake, flailing_drake,


@card("Anoint")
def anoint(card, abilities):

    def anoint():
        return AbilityNotImplemented

    def anoint():
        return AbilityNotImplemented

    return anoint, anoint,


@card("Corpse Dance")
def corpse_dance(card, abilities):

    def corpse_dance():
        return AbilityNotImplemented

    def corpse_dance():
        return AbilityNotImplemented

    return corpse_dance, corpse_dance,


@card("Diabolic Edict")
def diabolic_edict(card, abilities):

    def diabolic_edict():
        return AbilityNotImplemented

    return diabolic_edict,


@card("Blood Pet")
def blood_pet(card, abilities):

    def blood_pet():
        return AbilityNotImplemented

    return blood_pet,


@card("Safeguard")
def safeguard(card, abilities):

    def safeguard():
        return AbilityNotImplemented

    return safeguard,


@card("Legacy's Allure")
def legacys_allure(card, abilities):

    def legacys_allure():
        return AbilityNotImplemented

    def legacys_allure():
        return AbilityNotImplemented

    return legacys_allure, legacys_allure,


@card("Scragnoth")
def scragnoth(card, abilities):

    def scragnoth():
        return AbilityNotImplemented

    def scragnoth():
        return AbilityNotImplemented

    return scragnoth, scragnoth,


@card("Mirri's Guile")
def mirris_guile(card, abilities):

    def mirris_guile():
        return AbilityNotImplemented

    return mirris_guile,


@card("Maddening Imp")
def maddening_imp(card, abilities):

    def maddening_imp():
        return AbilityNotImplemented

    def maddening_imp():
        return AbilityNotImplemented

    return maddening_imp, maddening_imp,


@card("Sudden Impact")
def sudden_impact(card, abilities):

    def sudden_impact():
        return AbilityNotImplemented

    return sudden_impact,


@card("Hanna's Custody")
def hannas_custody(card, abilities):

    def hannas_custody():
        return AbilityNotImplemented

    return hannas_custody,


@card("Knight of Dusk")
def knight_of_dusk(card, abilities):

    def knight_of_dusk():
        return AbilityNotImplemented

    return knight_of_dusk,


@card("Scabland")
def scabland(card, abilities):

    def scabland():
        return AbilityNotImplemented

    def scabland():
        return AbilityNotImplemented

    def scabland():
        return AbilityNotImplemented

    return scabland, scabland, scabland,


@card("Sky Spirit")
def sky_spirit(card, abilities):

    def sky_spirit():
        return AbilityNotImplemented

    return sky_spirit,


@card("Tahngarth's Rage")
def tahngarths_rage(card, abilities):

    def tahngarths_rage():
        return AbilityNotImplemented

    def tahngarths_rage():
        return AbilityNotImplemented

    return tahngarths_rage, tahngarths_rage,


@card("Dauthi Slayer")
def dauthi_slayer(card, abilities):

    def dauthi_slayer():
        return AbilityNotImplemented

    def dauthi_slayer():
        return AbilityNotImplemented

    return dauthi_slayer, dauthi_slayer,


@card("Canyon Wildcat")
def canyon_wildcat(card, abilities):

    def canyon_wildcat():
        return AbilityNotImplemented

    return canyon_wildcat,


@card("Aluren")
def aluren(card, abilities):

    def aluren():
        return AbilityNotImplemented

    return aluren,


@card("Phyrexian Splicer")
def phyrexian_splicer(card, abilities):

    def phyrexian_splicer():
        return AbilityNotImplemented

    return phyrexian_splicer,


@card("Scorched Earth")
def scorched_earth(card, abilities):

    def scorched_earth():
        return AbilityNotImplemented

    def scorched_earth():
        return AbilityNotImplemented

    return scorched_earth, scorched_earth,


@card("Mogg Cannon")
def mogg_cannon(card, abilities):

    def mogg_cannon():
        return AbilityNotImplemented

    return mogg_cannon,


@card("Light of Day")
def light_of_day(card, abilities):

    def light_of_day():
        return AbilityNotImplemented

    return light_of_day,


@card("Clot Sliver")
def clot_sliver(card, abilities):

    def clot_sliver():
        return AbilityNotImplemented

    return clot_sliver,


@card("Warmth")
def warmth(card, abilities):

    def warmth():
        return AbilityNotImplemented

    return warmth,


@card("Static Orb")
def static_orb(card, abilities):

    def static_orb():
        return AbilityNotImplemented

    return static_orb,


@card("Jet Medallion")
def jet_medallion(card, abilities):

    def jet_medallion():
        return AbilityNotImplemented

    return jet_medallion,


@card("Pit Imp")
def pit_imp(card, abilities):

    def pit_imp():
        return AbilityNotImplemented

    def pit_imp():
        return AbilityNotImplemented

    return pit_imp, pit_imp,


@card("Pincher Beetles")
def pincher_beetles(card, abilities):

    def pincher_beetles():
        return AbilityNotImplemented

    return pincher_beetles,


@card("Tradewind Rider")
def tradewind_rider(card, abilities):

    def tradewind_rider():
        return AbilityNotImplemented

    def tradewind_rider():
        return AbilityNotImplemented

    return tradewind_rider, tradewind_rider,


@card("Soltari Guerrillas")
def soltari_guerrillas(card, abilities):

    def soltari_guerrillas():
        return AbilityNotImplemented

    def soltari_guerrillas():
        return AbilityNotImplemented

    return soltari_guerrillas, soltari_guerrillas,


@card("Bayou Dragonfly")
def bayou_dragonfly(card, abilities):

    def bayou_dragonfly():
        return AbilityNotImplemented

    return bayou_dragonfly,


@card("Marble Titan")
def marble_titan(card, abilities):

    def marble_titan():
        return AbilityNotImplemented

    return marble_titan,


@card("Whim of Volrath")
def whim_of_volrath(card, abilities):

    def whim_of_volrath():
        return AbilityNotImplemented

    def whim_of_volrath():
        return AbilityNotImplemented

    return whim_of_volrath, whim_of_volrath,


@card("Shadow Rift")
def shadow_rift(card, abilities):

    def shadow_rift():
        return AbilityNotImplemented

    def shadow_rift():
        return AbilityNotImplemented

    return shadow_rift, shadow_rift,


@card("Excavator")
def excavator(card, abilities):

    def excavator():
        return AbilityNotImplemented

    return excavator,


@card("Nature's Revolt")
def natures_revolt(card, abilities):

    def natures_revolt():
        return AbilityNotImplemented

    return natures_revolt,


@card("Vhati il-Dal")
def vhati_ildal(card, abilities):

    def vhati_ildal():
        return AbilityNotImplemented

    return vhati_ildal,


@card("Evincar's Justice")
def evincars_justice(card, abilities):

    def evincars_justice():
        return AbilityNotImplemented

    def evincars_justice():
        return AbilityNotImplemented

    return evincars_justice, evincars_justice,


@card("Precognition")
def precognition(card, abilities):

    def precognition():
        return AbilityNotImplemented

    return precognition,


@card("Souldrinker")
def souldrinker(card, abilities):

    def souldrinker():
        return AbilityNotImplemented

    return souldrinker,


@card("Rootwalla")
def rootwalla(card, abilities):

    def rootwalla():
        return AbilityNotImplemented

    return rootwalla,


@card("Skyshroud Elf")
def skyshroud_elf(card, abilities):

    def skyshroud_elf():
        return AbilityNotImplemented

    def skyshroud_elf():
        return AbilityNotImplemented

    return skyshroud_elf, skyshroud_elf,


@card("Mogg Squad")
def mogg_squad(card, abilities):

    def mogg_squad():
        return AbilityNotImplemented

    return mogg_squad,


@card("Canopy Spider")
def canopy_spider(card, abilities):

    def canopy_spider():
        return AbilityNotImplemented

    return canopy_spider,


@card("Sandstone Warrior")
def sandstone_warrior(card, abilities):

    def sandstone_warrior():
        return AbilityNotImplemented

    def sandstone_warrior():
        return AbilityNotImplemented

    return sandstone_warrior, sandstone_warrior,


@card("Gallantry")
def gallantry(card, abilities):

    def gallantry():
        return AbilityNotImplemented

    def gallantry():
        return AbilityNotImplemented

    return gallantry, gallantry,


@card("Rootwater Matriarch")
def rootwater_matriarch(card, abilities):

    def rootwater_matriarch():
        return AbilityNotImplemented

    return rootwater_matriarch,


@card("Mogg Raider")
def mogg_raider(card, abilities):

    def mogg_raider():
        return AbilityNotImplemented

    return mogg_raider,


@card("Fool's Tome")
def fools_tome(card, abilities):

    def fools_tome():
        return AbilityNotImplemented

    return fools_tome,


@card("Escaped Shapeshifter")
def escaped_shapeshifter(card, abilities):

    def escaped_shapeshifter():
        return AbilityNotImplemented

    return escaped_shapeshifter,


@card("Shadowstorm")
def shadowstorm(card, abilities):

    def shadowstorm():
        return AbilityNotImplemented

    return shadowstorm,


@card("Rolling Thunder")
def rolling_thunder(card, abilities):

    def rolling_thunder():
        return AbilityNotImplemented

    return rolling_thunder,


@card("Intuition")
def intuition(card, abilities):

    def intuition():
        return AbilityNotImplemented

    return intuition,


@card("Lobotomy")
def lobotomy(card, abilities):

    def lobotomy():
        return AbilityNotImplemented

    return lobotomy,


@card("Mogg Conscripts")
def mogg_conscripts(card, abilities):

    def mogg_conscripts():
        return AbilityNotImplemented

    return mogg_conscripts,


@card("Master Decoy")
def master_decoy(card, abilities):

    def master_decoy():
        return AbilityNotImplemented

    return master_decoy,


@card("Steal Enchantment")
def steal_enchantment(card, abilities):

    def steal_enchantment():
        return AbilityNotImplemented

    def steal_enchantment():
        return AbilityNotImplemented

    return steal_enchantment, steal_enchantment,


@card("Dread of Night")
def dread_of_night(card, abilities):

    def dread_of_night():
        return AbilityNotImplemented

    return dread_of_night,


@card("Meditate")
def meditate(card, abilities):

    def meditate():
        return AbilityNotImplemented

    return meditate,


@card("Apocalypse")
def apocalypse(card, abilities):

    def apocalypse():
        return AbilityNotImplemented

    return apocalypse,


@card("Magmasaur")
def magmasaur(card, abilities):

    def magmasaur():
        return AbilityNotImplemented

    def magmasaur():
        return AbilityNotImplemented

    return magmasaur, magmasaur,


@card("Reckless Spite")
def reckless_spite(card, abilities):

    def reckless_spite():
        return AbilityNotImplemented

    return reckless_spite,


@card("Soltari Foot Soldier")
def soltari_foot_soldier(card, abilities):

    def soltari_foot_soldier():
        return AbilityNotImplemented

    return soltari_foot_soldier,


@card("Benthic Behemoth")
def benthic_behemoth(card, abilities):

    def benthic_behemoth():
        return AbilityNotImplemented

    return benthic_behemoth,


@card("Reality Anchor")
def reality_anchor(card, abilities):

    def reality_anchor():
        return AbilityNotImplemented

    def reality_anchor():
        return AbilityNotImplemented

    return reality_anchor, reality_anchor,


@card("Phyrexian Grimoire")
def phyrexian_grimoire(card, abilities):

    def phyrexian_grimoire():
        return AbilityNotImplemented

    return phyrexian_grimoire,


@card("Sadistic Glee")
def sadistic_glee(card, abilities):

    def sadistic_glee():
        return AbilityNotImplemented

    def sadistic_glee():
        return AbilityNotImplemented

    return sadistic_glee, sadistic_glee,


@card("Krakilin")
def krakilin(card, abilities):

    def krakilin():
        return AbilityNotImplemented

    def krakilin():
        return AbilityNotImplemented

    return krakilin, krakilin,


@card("Verdigris")
def verdigris(card, abilities):

    def verdigris():
        return AbilityNotImplemented

    return verdigris,


@card("Magnetic Web")
def magnetic_web(card, abilities):

    def magnetic_web():
        return AbilityNotImplemented

    def magnetic_web():
        return AbilityNotImplemented

    def magnetic_web():
        return AbilityNotImplemented

    return magnetic_web, magnetic_web, magnetic_web,


@card("Staunch Defenders")
def staunch_defenders(card, abilities):

    def staunch_defenders():
        return AbilityNotImplemented

    return staunch_defenders,


@card("Avenging Angel")
def avenging_angel(card, abilities):

    def avenging_angel():
        return AbilityNotImplemented

    def avenging_angel():
        return AbilityNotImplemented

    return avenging_angel, avenging_angel,


@card("Dracoplasm")
def dracoplasm(card, abilities):

    def dracoplasm():
        return AbilityNotImplemented

    def dracoplasm():
        return AbilityNotImplemented

    def dracoplasm():
        return AbilityNotImplemented

    return dracoplasm, dracoplasm, dracoplasm,


@card("Rootwater Hunter")
def rootwater_hunter(card, abilities):

    def rootwater_hunter():
        return AbilityNotImplemented

    return rootwater_hunter,


@card("Torture Chamber")
def torture_chamber(card, abilities):

    def torture_chamber():
        return AbilityNotImplemented

    def torture_chamber():
        return AbilityNotImplemented

    def torture_chamber():
        return AbilityNotImplemented

    return torture_chamber, torture_chamber, torture_chamber,


@card("Spontaneous Combustion")
def spontaneous_combustion(card, abilities):

    def spontaneous_combustion():
        return AbilityNotImplemented

    def spontaneous_combustion():
        return AbilityNotImplemented

    return spontaneous_combustion, spontaneous_combustion,


@card("Living Death")
def living_death(card, abilities):

    def living_death():
        return AbilityNotImplemented

    return living_death,


@card("Skyshroud Condor")
def skyshroud_condor(card, abilities):

    def skyshroud_condor():
        return AbilityNotImplemented

    def skyshroud_condor():
        return AbilityNotImplemented

    return skyshroud_condor, skyshroud_condor,


@card("Scalding Tongs")
def scalding_tongs(card, abilities):

    def scalding_tongs():
        return AbilityNotImplemented

    return scalding_tongs,


@card("Squee's Toy")
def squees_toy(card, abilities):

    def squees_toy():
        return AbilityNotImplemented

    return squees_toy,


@card("Soltari Crusader")
def soltari_crusader(card, abilities):

    def soltari_crusader():
        return AbilityNotImplemented

    def soltari_crusader():
        return AbilityNotImplemented

    return soltari_crusader, soltari_crusader,


@card("Duplicity")
def duplicity(card, abilities):

    def duplicity():
        return AbilityNotImplemented

    def duplicity():
        return AbilityNotImplemented

    def duplicity():
        return AbilityNotImplemented

    def duplicity():
        return AbilityNotImplemented

    return duplicity, duplicity, duplicity, duplicity,


@card("Interdict")
def interdict(card, abilities):

    def interdict():
        return AbilityNotImplemented

    def interdict():
        return AbilityNotImplemented

    return interdict, interdict,


@card("Marsh Lurker")
def marsh_lurker(card, abilities):

    def marsh_lurker():
        return AbilityNotImplemented

    return marsh_lurker,


@card("Ertai's Meddling")
def ertais_meddling(card, abilities):

    def ertais_meddling():
        return AbilityNotImplemented

    def ertais_meddling():
        return AbilityNotImplemented

    def ertais_meddling():
        return AbilityNotImplemented

    return ertais_meddling, ertais_meddling, ertais_meddling,


@card("Crown of Flames")
def crown_of_flames(card, abilities):

    def crown_of_flames():
        return AbilityNotImplemented

    def crown_of_flames():
        return AbilityNotImplemented

    def crown_of_flames():
        return AbilityNotImplemented

    return crown_of_flames, crown_of_flames, crown_of_flames,


@card("Wild Wurm")
def wild_wurm(card, abilities):

    def wild_wurm():
        return AbilityNotImplemented

    return wild_wurm,


@card("Soltari Lancer")
def soltari_lancer(card, abilities):

    def soltari_lancer():
        return AbilityNotImplemented

    def soltari_lancer():
        return AbilityNotImplemented

    return soltari_lancer, soltari_lancer,


@card("Fylamarid")
def fylamarid(card, abilities):

    def fylamarid():
        return AbilityNotImplemented

    def fylamarid():
        return AbilityNotImplemented

    def fylamarid():
        return AbilityNotImplemented

    return fylamarid, fylamarid, fylamarid,


@card("Grindstone")
def grindstone(card, abilities):

    def grindstone():
        return AbilityNotImplemented

    return grindstone,


@card("Time Warp")
def time_warp(card, abilities):

    def time_warp():
        return AbilityNotImplemented

    return time_warp,


@card("Horned Sliver")
def horned_sliver(card, abilities):

    def horned_sliver():
        return AbilityNotImplemented

    return horned_sliver,


@card("Mnemonic Sliver")
def mnemonic_sliver(card, abilities):

    def mnemonic_sliver():
        return AbilityNotImplemented

    return mnemonic_sliver,


@card("Thalakos Dreamsower")
def thalakos_dreamsower(card, abilities):

    def thalakos_dreamsower():
        return AbilityNotImplemented

    def thalakos_dreamsower():
        return AbilityNotImplemented

    def thalakos_dreamsower():
        return AbilityNotImplemented

    return thalakos_dreamsower, thalakos_dreamsower, thalakos_dreamsower,


@card("Nurturing Licid")
def nurturing_licid(card, abilities):

    def nurturing_licid():
        return AbilityNotImplemented

    def nurturing_licid():
        return AbilityNotImplemented

    return nurturing_licid, nurturing_licid,


@card("Heartwood Treefolk")
def heartwood_treefolk(card, abilities):

    def heartwood_treefolk():
        return AbilityNotImplemented

    return heartwood_treefolk,


@card("Imps' Taunt")
def imps_taunt(card, abilities):

    def imps_taunt():
        return AbilityNotImplemented

    def imps_taunt():
        return AbilityNotImplemented

    return imps_taunt, imps_taunt,


@card("Lotus Petal")
def lotus_petal(card, abilities):

    def lotus_petal():
        return AbilityNotImplemented

    return lotus_petal,


@card("Thalakos Lowlands")
def thalakos_lowlands(card, abilities):

    def thalakos_lowlands():
        return AbilityNotImplemented

    def thalakos_lowlands():
        return AbilityNotImplemented

    return thalakos_lowlands, thalakos_lowlands,


@card("Rootwater Shaman")
def rootwater_shaman(card, abilities):

    def rootwater_shaman():
        return AbilityNotImplemented

    return rootwater_shaman,


@card("Thalakos Seer")
def thalakos_seer(card, abilities):

    def thalakos_seer():
        return AbilityNotImplemented

    def thalakos_seer():
        return AbilityNotImplemented

    return thalakos_seer, thalakos_seer,


@card("Kezzerdrix")
def kezzerdrix(card, abilities):

    def kezzerdrix():
        return AbilityNotImplemented

    def kezzerdrix():
        return AbilityNotImplemented

    return kezzerdrix, kezzerdrix,


@card("Sea Monster")
def sea_monster(card, abilities):

    def sea_monster():
        return AbilityNotImplemented

    return sea_monster,


@card("Hand to Hand")
def hand_to_hand(card, abilities):

    def hand_to_hand():
        return AbilityNotImplemented

    return hand_to_hand,


@card("Angelic Protector")
def angelic_protector(card, abilities):

    def angelic_protector():
        return AbilityNotImplemented

    def angelic_protector():
        return AbilityNotImplemented

    return angelic_protector, angelic_protector,


@card("Talon Sliver")
def talon_sliver(card, abilities):

    def talon_sliver():
        return AbilityNotImplemented

    return talon_sliver,


@card("Gerrard's Battle Cry")
def gerrards_battle_cry(card, abilities):

    def gerrards_battle_cry():
        return AbilityNotImplemented

    return gerrards_battle_cry,


@card("Respite")
def respite(card, abilities):

    def respite():
        return AbilityNotImplemented

    return respite,


@card("Cursed Scroll")
def cursed_scroll(card, abilities):

    def cursed_scroll():
        return AbilityNotImplemented

    return cursed_scroll,


@card("Puppet Strings")
def puppet_strings(card, abilities):

    def puppet_strings():
        return AbilityNotImplemented

    return puppet_strings,


@card("Aftershock")
def aftershock(card, abilities):

    def aftershock():
        return AbilityNotImplemented

    return aftershock,


@card("Capsize")
def capsize(card, abilities):

    def capsize():
        return AbilityNotImplemented

    def capsize():
        return AbilityNotImplemented

    return capsize, capsize,


@card("Mogg Fanatic")
def mogg_fanatic(card, abilities):

    def mogg_fanatic():
        return AbilityNotImplemented

    return mogg_fanatic,


@card("Shocker")
def shocker(card, abilities):

    def shocker():
        return AbilityNotImplemented

    return shocker,


@card("Selenia, Dark Angel")
def selenia_dark_angel(card, abilities):

    def selenia_dark_angel():
        return AbilityNotImplemented

    def selenia_dark_angel():
        return AbilityNotImplemented

    return selenia_dark_angel, selenia_dark_angel,


@card("Disturbed Burial")
def disturbed_burial(card, abilities):

    def disturbed_burial():
        return AbilityNotImplemented

    def disturbed_burial():
        return AbilityNotImplemented

    return disturbed_burial, disturbed_burial,


@card("Manta Riders")
def manta_riders(card, abilities):

    def manta_riders():
        return AbilityNotImplemented

    return manta_riders,


@card("Hero's Resolve")
def heros_resolve(card, abilities):

    def heros_resolve():
        return AbilityNotImplemented

    def heros_resolve():
        return AbilityNotImplemented

    return heros_resolve, heros_resolve,


@card("Volrath's Curse")
def volraths_curse(card, abilities):

    def volraths_curse():
        return AbilityNotImplemented

    def volraths_curse():
        return AbilityNotImplemented

    def volraths_curse():
        return AbilityNotImplemented

    return volraths_curse, volraths_curse, volraths_curse,


@card("Dauthi Ghoul")
def dauthi_ghoul(card, abilities):

    def dauthi_ghoul():
        return AbilityNotImplemented

    def dauthi_ghoul():
        return AbilityNotImplemented

    return dauthi_ghoul, dauthi_ghoul,


@card("Thalakos Sentry")
def thalakos_sentry(card, abilities):

    def thalakos_sentry():
        return AbilityNotImplemented

    return thalakos_sentry,


@card("Helm of Possession")
def helm_of_possession(card, abilities):

    def helm_of_possession():
        return AbilityNotImplemented

    def helm_of_possession():
        return AbilityNotImplemented

    return helm_of_possession, helm_of_possession,


@card("Segmented Wurm")
def segmented_wurm(card, abilities):

    def segmented_wurm():
        return AbilityNotImplemented

    return segmented_wurm,


@card("Repentance")
def repentance(card, abilities):

    def repentance():
        return AbilityNotImplemented

    return repentance,


@card("Trumpeting Armodon")
def trumpeting_armodon(card, abilities):

    def trumpeting_armodon():
        return AbilityNotImplemented

    return trumpeting_armodon,


@card("Darkling Stalker")
def darkling_stalker(card, abilities):

    def darkling_stalker():
        return AbilityNotImplemented

    def darkling_stalker():
        return AbilityNotImplemented

    return darkling_stalker, darkling_stalker,


@card("Vec Townships")
def vec_townships(card, abilities):

    def vec_townships():
        return AbilityNotImplemented

    def vec_townships():
        return AbilityNotImplemented

    return vec_townships, vec_townships,


@card("Lightning Blast")
def lightning_blast(card, abilities):

    def lightning_blast():
        return AbilityNotImplemented

    return lightning_blast,


@card("Sapphire Medallion")
def sapphire_medallion(card, abilities):

    def sapphire_medallion():
        return AbilityNotImplemented

    return sapphire_medallion,


@card("Spirit Mirror")
def spirit_mirror(card, abilities):

    def spirit_mirror():
        return AbilityNotImplemented

    def spirit_mirror():
        return AbilityNotImplemented

    return spirit_mirror, spirit_mirror,


@card("Verdant Force")
def verdant_force(card, abilities):

    def verdant_force():
        return AbilityNotImplemented

    return verdant_force,


@card("Pine Barrens")
def pine_barrens(card, abilities):

    def pine_barrens():
        return AbilityNotImplemented

    def pine_barrens():
        return AbilityNotImplemented

    def pine_barrens():
        return AbilityNotImplemented

    return pine_barrens, pine_barrens, pine_barrens,


@card("No Quarter")
def no_quarter(card, abilities):

    def no_quarter():
        return AbilityNotImplemented

    def no_quarter():
        return AbilityNotImplemented

    return no_quarter, no_quarter,


@card("Patchwork Gnomes")
def patchwork_gnomes(card, abilities):

    def patchwork_gnomes():
        return AbilityNotImplemented

    return patchwork_gnomes,


@card("Winds of Rath")
def winds_of_rath(card, abilities):

    def winds_of_rath():
        return AbilityNotImplemented

    return winds_of_rath,


@card("Maze of Shadows")
def maze_of_shadows(card, abilities):

    def maze_of_shadows():
        return AbilityNotImplemented

    def maze_of_shadows():
        return AbilityNotImplemented

    return maze_of_shadows, maze_of_shadows,


@card("Rathi Dragon")
def rathi_dragon(card, abilities):

    def rathi_dragon():
        return AbilityNotImplemented

    def rathi_dragon():
        return AbilityNotImplemented

    return rathi_dragon, rathi_dragon,


@card("Flowstone Giant")
def flowstone_giant(card, abilities):

    def flowstone_giant():
        return AbilityNotImplemented

    return flowstone_giant,


@card("Dirtcowl Wurm")
def dirtcowl_wurm(card, abilities):

    def dirtcowl_wurm():
        return AbilityNotImplemented

    return dirtcowl_wurm,


@card("Pallimud")
def pallimud(card, abilities):

    def pallimud():
        return AbilityNotImplemented

    def pallimud():
        return AbilityNotImplemented

    return pallimud, pallimud,


@card("Ranger en-Vec")
def ranger_envec(card, abilities):

    def ranger_envec():
        return AbilityNotImplemented

    def ranger_envec():
        return AbilityNotImplemented

    return ranger_envec, ranger_envec,


@card("Scroll Rack")
def scroll_rack(card, abilities):

    def scroll_rack():
        return AbilityNotImplemented

    return scroll_rack,


@card("Invulnerability")
def invulnerability(card, abilities):

    def invulnerability():
        return AbilityNotImplemented

    def invulnerability():
        return AbilityNotImplemented

    return invulnerability, invulnerability,


@card("Armor Sliver")
def armor_sliver(card, abilities):

    def armor_sliver():
        return AbilityNotImplemented

    return armor_sliver,


@card("Seeker of Skybreak")
def seeker_of_skybreak(card, abilities):

    def seeker_of_skybreak():
        return AbilityNotImplemented

    return seeker_of_skybreak,


@card("Knight of Dawn")
def knight_of_dawn(card, abilities):

    def knight_of_dawn():
        return AbilityNotImplemented

    def knight_of_dawn():
        return AbilityNotImplemented

    return knight_of_dawn, knight_of_dawn,


@card("Soltari Priest")
def soltari_priest(card, abilities):

    def soltari_priest():
        return AbilityNotImplemented

    def soltari_priest():
        return AbilityNotImplemented

    return soltari_priest, soltari_priest,


@card("Coiled Tinviper")
def coiled_tinviper(card, abilities):

    def coiled_tinviper():
        return AbilityNotImplemented

    return coiled_tinviper,


@card("Reanimate")
def reanimate(card, abilities):

    def reanimate():
        return AbilityNotImplemented

    return reanimate,


@card("Dauthi Embrace")
def dauthi_embrace(card, abilities):

    def dauthi_embrace():
        return AbilityNotImplemented

    return dauthi_embrace,


@card("Soltari Emissary")
def soltari_emissary(card, abilities):

    def soltari_emissary():
        return AbilityNotImplemented

    return soltari_emissary,


@card("Whispers of the Muse")
def whispers_of_the_muse(card, abilities):

    def whispers_of_the_muse():
        return AbilityNotImplemented

    def whispers_of_the_muse():
        return AbilityNotImplemented

    return whispers_of_the_muse, whispers_of_the_muse,


@card("Perish")
def perish(card, abilities):

    def perish():
        return AbilityNotImplemented

    return perish,


@card("Apes of Rath")
def apes_of_rath(card, abilities):

    def apes_of_rath():
        return AbilityNotImplemented

    return apes_of_rath,


@card("Recycle")
def recycle(card, abilities):

    def recycle():
        return AbilityNotImplemented

    def recycle():
        return AbilityNotImplemented

    def recycle():
        return AbilityNotImplemented

    return recycle, recycle, recycle,


@card("Wind Dancer")
def wind_dancer(card, abilities):

    def wind_dancer():
        return AbilityNotImplemented

    def wind_dancer():
        return AbilityNotImplemented

    return wind_dancer, wind_dancer,


@card("Furnace of Rath")
def furnace_of_rath(card, abilities):

    def furnace_of_rath():
        return AbilityNotImplemented

    return furnace_of_rath,


@card("Thumbscrews")
def thumbscrews(card, abilities):

    def thumbscrews():
        return AbilityNotImplemented

    return thumbscrews,


@card("Dregs of Sorrow")
def dregs_of_sorrow(card, abilities):

    def dregs_of_sorrow():
        return AbilityNotImplemented

    return dregs_of_sorrow,


@card("Wood Sage")
def wood_sage(card, abilities):

    def wood_sage():
        return AbilityNotImplemented

    return wood_sage,


@card("Soltari Trooper")
def soltari_trooper(card, abilities):

    def soltari_trooper():
        return AbilityNotImplemented

    def soltari_trooper():
        return AbilityNotImplemented

    return soltari_trooper, soltari_trooper,


@card("Dauthi Horror")
def dauthi_horror(card, abilities):

    def dauthi_horror():
        return AbilityNotImplemented

    def dauthi_horror():
        return AbilityNotImplemented

    return dauthi_horror, dauthi_horror,


@card("Bellowing Fiend")
def bellowing_fiend(card, abilities):

    def bellowing_fiend():
        return AbilityNotImplemented

    def bellowing_fiend():
        return AbilityNotImplemented

    return bellowing_fiend, bellowing_fiend,


@card("Skyshroud Ranger")
def skyshroud_ranger(card, abilities):

    def skyshroud_ranger():
        return AbilityNotImplemented

    return skyshroud_ranger,


@card("Havoc")
def havoc(card, abilities):

    def havoc():
        return AbilityNotImplemented

    return havoc,