import pytest

from engine.game.game_state import initialize_game


@pytest.fixture
def game():
    return initialize_game(deck_type="training")


def _find_card(game, cid):
    # Check Member DB
    if hasattr(game, "member_db"):
        if cid in game.member_db:
            return game.member_db[cid]
    # Check Live DB
    if hasattr(game, "live_db"):
        if cid in game.live_db:
            return game.live_db[cid]
    # Check Energy DB (if exists)
    if hasattr(game, "energy_db"):
        if cid in game.energy_db:
            return game.energy_db[cid]
    return None


def test_strict_LL_bp1_001_R__0(game):
    cid = 0
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_LL_bp2_001_R__1(game):
    cid = 1
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_LL_bp3_001_R__2(game):
    cid = 2
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 6, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_LL_bp4_001_R__3(game):
    cid = 3
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL__PR_001_PR_4(game):
    cid = 4
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_002_PR_5(game):
    cid = 5
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_003_PR_6(game):
    cid = 6
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_004_PR_7(game):
    cid = 7
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_005_PR_8(game):
    cid = 8
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_006_PR_9(game):
    cid = 9
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_007_PR_10(game):
    cid = 10
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL__PR_008_PR_11(game):
    cid = 11
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__PR_009_PR_12(game):
    cid = 12
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL__bp3_001_P_13(game):
    cid = 13
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_001_R_14(game):
    cid = 14
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_001_R_15(game):
    cid = 15
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_001_P_16(game):
    cid = 16
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_002_P_17(game):
    cid = 17
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_002_R_18(game):
    cid = 18
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_002_R_19(game):
    cid = 19
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_002_P_20(game):
    cid = 20
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_003_P_21(game):
    cid = 21
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp3_003_R_22(game):
    cid = 22
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp3_003_R_23(game):
    cid = 23
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp3_003_P_24(game):
    cid = 24
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp3_004_P_25(game):
    cid = 25
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_R__26(game):
    cid = 26
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P__27(game):
    cid = 27
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_SEC_28(game):
    cid = 28
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P__29(game):
    cid = 29
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_R__30(game):
    cid = 30
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P_31(game):
    cid = 31
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_SEC_32(game):
    cid = 32
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_R__33(game):
    cid = 33
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P_34(game):
    cid = 34
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P__35(game):
    cid = 35
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_SEC_36(game):
    cid = 36
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_SEC_37(game):
    cid = 37
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_R__38(game):
    cid = 38
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P_39(game):
    cid = 39
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_004_P__40(game):
    cid = 40
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_005_P_41(game):
    cid = 41
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"


def test_strict_PL__bp3_005_R_42(game):
    cid = 42
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"


def test_strict_PL__bp3_005_R_43(game):
    cid = 43
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"


def test_strict_PL__bp3_005_P_44(game):
    cid = 44
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"


def test_strict_PL__bp3_006_P_45(game):
    cid = 45
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_006_R_46(game):
    cid = 46
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_006_R_47(game):
    cid = 47
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_006_P_48(game):
    cid = 48
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_007_P_49(game):
    cid = 49
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 41, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_007_R_50(game):
    cid = 50
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 41, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_007_R_51(game):
    cid = 51
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 41, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_007_P_52(game):
    cid = 52
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 41, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_008_P_53(game):
    cid = 53
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_R__54(game):
    cid = 54
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P__55(game):
    cid = 55
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_SEC_56(game):
    cid = 56
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P__57(game):
    cid = 57
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_R__58(game):
    cid = 58
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P_59(game):
    cid = 59
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_SEC_60(game):
    cid = 60
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_R__61(game):
    cid = 61
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P_62(game):
    cid = 62
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P__63(game):
    cid = 63
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_SEC_64(game):
    cid = 64
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_SEC_65(game):
    cid = 65
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_R__66(game):
    cid = 66
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P_67(game):
    cid = 67
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_008_P__68(game):
    cid = 68
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp3_009_P_69(game):
    cid = 69
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_R__70(game):
    cid = 70
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P__71(game):
    cid = 71
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_SEC_72(game):
    cid = 72
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P__73(game):
    cid = 73
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_R__74(game):
    cid = 74
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P_75(game):
    cid = 75
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_SEC_76(game):
    cid = 76
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_R__77(game):
    cid = 77
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P_78(game):
    cid = 78
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P__79(game):
    cid = 79
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_SEC_80(game):
    cid = 80
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_SEC_81(game):
    cid = 81
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_R__82(game):
    cid = 82
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P_83(game):
    cid = 83
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_009_P__84(game):
    cid = 84
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 4, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 37, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 17, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab1.effects[3].effect_type == 2, "Effect 3 type mismatch"
    assert ab1.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_010_N_85(game):
    cid = 85
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_011_N_86(game):
    cid = 86
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_012_N_87(game):
    cid = 87
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_012_PR_88(game):
    cid = 88
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_012_PR_89(game):
    cid = 89
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_012_N_90(game):
    cid = 90
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_013_N_91(game):
    cid = 91
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__bp3_014_N_92(game):
    cid = 92
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL__bp3_015_N_93(game):
    cid = 93
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_016_N_94(game):
    cid = 94
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_017_N_95(game):
    cid = 95
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL__bp3_018_N_96(game):
    cid = 96
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 27, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL__bp4_001_P_97(game):
    cid = 97
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 21, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_001_R_98(game):
    cid = 98
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 21, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_001_R_99(game):
    cid = 99
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 21, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_001_P_100(game):
    cid = 100
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 21, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P_101(game):
    cid = 101
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_R__102(game):
    cid = 102
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P__103(game):
    cid = 103
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_SEC_104(game):
    cid = 104
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P__105(game):
    cid = 105
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_R__106(game):
    cid = 106
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P_107(game):
    cid = 107
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_SEC_108(game):
    cid = 108
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_R__109(game):
    cid = 109
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P_110(game):
    cid = 110
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P__111(game):
    cid = 111
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_SEC_112(game):
    cid = 112
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_SEC_113(game):
    cid = 113
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_R__114(game):
    cid = 114
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P_115(game):
    cid = 115
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_002_P__116(game):
    cid = 116
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_003_P_117(game):
    cid = 117
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp4_003_R_118(game):
    cid = 118
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp4_003_R_119(game):
    cid = 119
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp4_003_P_120(game):
    cid = 120
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp4_004_P_121(game):
    cid = 121
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_004_R_122(game):
    cid = 122
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_004_R_123(game):
    cid = 123
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_004_P_124(game):
    cid = 124
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P_125(game):
    cid = 125
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_R__126(game):
    cid = 126
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P__127(game):
    cid = 127
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_SEC_128(game):
    cid = 128
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P__129(game):
    cid = 129
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_R__130(game):
    cid = 130
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P_131(game):
    cid = 131
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_SEC_132(game):
    cid = 132
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_R__133(game):
    cid = 133
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P_134(game):
    cid = 134
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P__135(game):
    cid = 135
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_SEC_136(game):
    cid = 136
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_SEC_137(game):
    cid = 137
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_R__138(game):
    cid = 138
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P_139(game):
    cid = 139
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_005_P__140(game):
    cid = 140
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_006_P_141(game):
    cid = 141
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_006_R_142(game):
    cid = 142
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_006_R_143(game):
    cid = 143
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_006_P_144(game):
    cid = 144
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_007_P_145(game):
    cid = 145
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_007_R_146(game):
    cid = 146
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_007_R_147(game):
    cid = 147
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_007_P_148(game):
    cid = 148
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_008_P_149(game):
    cid = 149
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL__bp4_008_R_150(game):
    cid = 150
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL__bp4_008_R_151(game):
    cid = 151
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL__bp4_008_P_152(game):
    cid = 152
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL__bp4_009_P_153(game):
    cid = 153
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_009_R_154(game):
    cid = 154
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_009_R_155(game):
    cid = 155
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_009_P_156(game):
    cid = 156
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_010_N_157(game):
    cid = 157
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_011_N_158(game):
    cid = 158
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_012_N_159(game):
    cid = 159
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_013_N_160(game):
    cid = 160
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_014_N_161(game):
    cid = 161
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_015_N_162(game):
    cid = 162
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_016_N_163(game):
    cid = 163
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_017_N_164(game):
    cid = 164
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_018_N_165(game):
    cid = 165
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__pb1_001_P__166(game):
    cid = 166
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_001_R_167(game):
    cid = 167
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_001_R_168(game):
    cid = 168
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_001_P__169(game):
    cid = 169
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_002_P__170(game):
    cid = 170
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_002_R_171(game):
    cid = 171
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_002_R_172(game):
    cid = 172
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_002_P__173(game):
    cid = 173
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_003_P__174(game):
    cid = 174
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_003_R_175(game):
    cid = 175
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_003_R_176(game):
    cid = 176
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_003_P__177(game):
    cid = 177
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_004_P__178(game):
    cid = 178
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_004_R_179(game):
    cid = 179
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_004_R_180(game):
    cid = 180
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_004_P__181(game):
    cid = 181
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_005_P__182(game):
    cid = 182
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_005_R_183(game):
    cid = 183
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_005_R_184(game):
    cid = 184
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_005_P__185(game):
    cid = 185
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_006_P__186(game):
    cid = 186
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_006_R_187(game):
    cid = 187
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_006_R_188(game):
    cid = 188
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_006_P__189(game):
    cid = 189
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_007_P__190(game):
    cid = 190
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_007_R_191(game):
    cid = 191
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_007_R_192(game):
    cid = 192
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_007_P__193(game):
    cid = 193
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_008_P__194(game):
    cid = 194
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_008_R_195(game):
    cid = 195
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_008_R_196(game):
    cid = 196
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_008_P__197(game):
    cid = 197
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_009_P__198(game):
    cid = 198
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 99, "Effect 2 value mismatch"


def test_strict_PL__pb1_009_R_199(game):
    cid = 199
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 99, "Effect 2 value mismatch"


def test_strict_PL__pb1_009_R_200(game):
    cid = 200
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 99, "Effect 2 value mismatch"


def test_strict_PL__pb1_009_P__201(game):
    cid = 201
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 99, "Effect 2 value mismatch"


def test_strict_PL__pb1_010_P__202(game):
    cid = 202
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_010_R_203(game):
    cid = 203
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_010_R_204(game):
    cid = 204
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_010_P__205(game):
    cid = 205
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_011_P__206(game):
    cid = 206
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 9, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_011_R_207(game):
    cid = 207
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 9, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_011_R_208(game):
    cid = 208
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 9, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_011_P__209(game):
    cid = 209
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 9, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_012_P__210(game):
    cid = 210
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_012_R_211(game):
    cid = 211
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_012_R_212(game):
    cid = 212
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_012_P__213(game):
    cid = 213
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_013_P__214(game):
    cid = 214
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_013_R_215(game):
    cid = 215
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_013_R_216(game):
    cid = 216
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_013_P__217(game):
    cid = 217
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_014_P__218(game):
    cid = 218
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__pb1_014_R_219(game):
    cid = 219
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__pb1_014_R_220(game):
    cid = 220
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__pb1_014_P__221(game):
    cid = 221
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__pb1_015_P__222(game):
    cid = 222
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 0, f"Trigger mismatch: {ab2.trigger} != 0"
    assert len(ab2.conditions) == 2, "Condition count mismatch"
    assert ab2.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab2.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_015_R_223(game):
    cid = 223
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 0, f"Trigger mismatch: {ab2.trigger} != 0"
    assert len(ab2.conditions) == 2, "Condition count mismatch"
    assert ab2.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab2.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_015_R_224(game):
    cid = 224
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 0, f"Trigger mismatch: {ab2.trigger} != 0"
    assert len(ab2.conditions) == 2, "Condition count mismatch"
    assert ab2.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab2.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_015_P__225(game):
    cid = 225
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 0, f"Trigger mismatch: {ab2.trigger} != 0"
    assert len(ab2.conditions) == 2, "Condition count mismatch"
    assert ab2.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab2.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_016_P__226(game):
    cid = 226
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_016_R_227(game):
    cid = 227
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_016_R_228(game):
    cid = 228
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_016_P__229(game):
    cid = 229
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_017_P__230(game):
    cid = 230
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__pb1_017_R_231(game):
    cid = 231
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__pb1_017_R_232(game):
    cid = 232
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__pb1_017_P__233(game):
    cid = 233
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__pb1_018_P__234(game):
    cid = 234
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_018_R_235(game):
    cid = 235
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_018_R_236(game):
    cid = 236
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_018_P__237(game):
    cid = 237
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_019_N_238(game):
    cid = 238
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_020_N_239(game):
    cid = 239
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_021_N_240(game):
    cid = 240
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_022_N_241(game):
    cid = 241
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_023_N_242(game):
    cid = 242
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_024_N_243(game):
    cid = 243
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_025_N_244(game):
    cid = 244
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_026_N_245(game):
    cid = 245
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_027_N_246(game):
    cid = 246
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_001_SD_247(game):
    cid = 247
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__sd1_002_SD_248(game):
    cid = 248
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_003_SD_249(game):
    cid = 249
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL__sd1_004_SD_250(game):
    cid = 250
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__sd1_005_SD_251(game):
    cid = 251
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_006_SD_252(game):
    cid = 252
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__sd1_007_SD_253(game):
    cid = 253
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_008_SD_254(game):
    cid = 254
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 10, "Effect 0 value mismatch"


def test_strict_PL__sd1_009_SD_255(game):
    cid = 255
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__sd1_010_SD_256(game):
    cid = 256
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_011_SD_257(game):
    cid = 257
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__sd1_012_SD_258(game):
    cid = 258
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_013_SD_259(game):
    cid = 259
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_014_SD_260(game):
    cid = 260
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_015_SD_261(game):
    cid = 261
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_016_SD_262(game):
    cid = 262
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__sd1_017_SD_263(game):
    cid = 263
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_018_SD_264(game):
    cid = 264
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_001_PR_265(game):
    cid = 265
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_002_PR_266(game):
    cid = 266
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_003_PR_267(game):
    cid = 267
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_004_PR_268(game):
    cid = 268
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_005_PR_269(game):
    cid = 269
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_006_PR_270(game):
    cid = 270
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_007_PR_271(game):
    cid = 271
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_008_PR_272(game):
    cid = 272
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_009_PR_273(game):
    cid = 273
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_014_PR_274(game):
    cid = 274
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_PR_016_PR_275(game):
    cid = 275
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_017_PR_276(game):
    cid = 276
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_018_PR_277(game):
    cid = 277
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_019_PR_278(game):
    cid = 278
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_020_PR_279(game):
    cid = 279
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_PR_021_PR_280(game):
    cid = 280
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_HS_PR_022_PR_281(game):
    cid = 281
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_PR_023_PR_282(game):
    cid = 282
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_001_P_283(game):
    cid = 283
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_001_R_284(game):
    cid = 284
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_001_R_285(game):
    cid = 285
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_001_P_286(game):
    cid = 286
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_002_P_287(game):
    cid = 287
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_002_R_288(game):
    cid = 288
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_002_R_289(game):
    cid = 289
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_002_P_290(game):
    cid = 290
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_003_P_291(game):
    cid = 291
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_R__292(game):
    cid = 292
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P__293(game):
    cid = 293
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_SEC_294(game):
    cid = 294
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P__295(game):
    cid = 295
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_R__296(game):
    cid = 296
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P_297(game):
    cid = 297
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_SEC_298(game):
    cid = 298
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_R__299(game):
    cid = 299
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P_300(game):
    cid = 300
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P__301(game):
    cid = 301
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_SEC_302(game):
    cid = 302
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_SEC_303(game):
    cid = 303
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_R__304(game):
    cid = 304
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P_305(game):
    cid = 305
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_003_P__306(game):
    cid = 306
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P_307(game):
    cid = 307
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_R__308(game):
    cid = 308
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P__309(game):
    cid = 309
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_SEC_310(game):
    cid = 310
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P__311(game):
    cid = 311
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_R__312(game):
    cid = 312
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P_313(game):
    cid = 313
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_SEC_314(game):
    cid = 314
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_R__315(game):
    cid = 315
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P_316(game):
    cid = 316
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P__317(game):
    cid = 317
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_SEC_318(game):
    cid = 318
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_SEC_319(game):
    cid = 319
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_R__320(game):
    cid = 320
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P_321(game):
    cid = 321
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_004_P__322(game):
    cid = 322
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_005_P_323(game):
    cid = 323
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_005_R_324(game):
    cid = 324
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_005_R_325(game):
    cid = 325
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_005_P_326(game):
    cid = 326
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_006_P_327(game):
    cid = 327
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_R__328(game):
    cid = 328
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P__329(game):
    cid = 329
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_SEC_330(game):
    cid = 330
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P__331(game):
    cid = 331
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_R__332(game):
    cid = 332
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P_333(game):
    cid = 333
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_SEC_334(game):
    cid = 334
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_R__335(game):
    cid = 335
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P_336(game):
    cid = 336
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P__337(game):
    cid = 337
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_SEC_338(game):
    cid = 338
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_SEC_339(game):
    cid = 339
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_R__340(game):
    cid = 340
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P_341(game):
    cid = 341
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_006_P__342(game):
    cid = 342
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_HS_bp1_007_P_343(game):
    cid = 343
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_007_R_344(game):
    cid = 344
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_007_R_345(game):
    cid = 345
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_007_P_346(game):
    cid = 346
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_008_P_347(game):
    cid = 347
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_008_R_348(game):
    cid = 348
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_008_R_349(game):
    cid = 349
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_008_P_350(game):
    cid = 350
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_009_P_351(game):
    cid = 351
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_009_R_352(game):
    cid = 352
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_009_R_353(game):
    cid = 353
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_009_P_354(game):
    cid = 354
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_010_N_355(game):
    cid = 355
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_011_N_356(game):
    cid = 356
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_012_N_357(game):
    cid = 357
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_012_PR_358(game):
    cid = 358
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_012_PR_359(game):
    cid = 359
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_012_N_360(game):
    cid = 360
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_013_N_361(game):
    cid = 361
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_014_N_362(game):
    cid = 362
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp1_015_N_363(game):
    cid = 363
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_016_N_364(game):
    cid = 364
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_017_N_365(game):
    cid = 365
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_018_N_366(game):
    cid = 366
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_001_P_367(game):
    cid = 367
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_001_R_368(game):
    cid = 368
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_001_R_369(game):
    cid = 369
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_001_P_370(game):
    cid = 370
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P_371(game):
    cid = 371
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_R__372(game):
    cid = 372
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P__373(game):
    cid = 373
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_SEC_374(game):
    cid = 374
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P__375(game):
    cid = 375
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_R__376(game):
    cid = 376
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P_377(game):
    cid = 377
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_SEC_378(game):
    cid = 378
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_R__379(game):
    cid = 379
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P_380(game):
    cid = 380
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P__381(game):
    cid = 381
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_SEC_382(game):
    cid = 382
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_SEC_383(game):
    cid = 383
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_R__384(game):
    cid = 384
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P_385(game):
    cid = 385
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_002_P__386(game):
    cid = 386
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_003_P_387(game):
    cid = 387
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_003_R_388(game):
    cid = 388
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_003_R_389(game):
    cid = 389
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_003_P_390(game):
    cid = 390
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_004_P_391(game):
    cid = 391
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_004_R_392(game):
    cid = 392
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_004_R_393(game):
    cid = 393
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_004_P_394(game):
    cid = 394
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_005_P_395(game):
    cid = 395
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_R__396(game):
    cid = 396
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P__397(game):
    cid = 397
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_SEC_398(game):
    cid = 398
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P__399(game):
    cid = 399
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_R__400(game):
    cid = 400
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P_401(game):
    cid = 401
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_SEC_402(game):
    cid = 402
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_R__403(game):
    cid = 403
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P_404(game):
    cid = 404
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P__405(game):
    cid = 405
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_SEC_406(game):
    cid = 406
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_SEC_407(game):
    cid = 407
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_R__408(game):
    cid = 408
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P_409(game):
    cid = 409
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_005_P__410(game):
    cid = 410
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_006_P_411(game):
    cid = 411
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_006_R_412(game):
    cid = 412
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_006_R_413(game):
    cid = 413
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_006_P_414(game):
    cid = 414
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_007_P_415(game):
    cid = 415
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_R__416(game):
    cid = 416
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P__417(game):
    cid = 417
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_SEC_418(game):
    cid = 418
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P__419(game):
    cid = 419
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_R__420(game):
    cid = 420
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P_421(game):
    cid = 421
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_SEC_422(game):
    cid = 422
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_R__423(game):
    cid = 423
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P_424(game):
    cid = 424
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P__425(game):
    cid = 425
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_SEC_426(game):
    cid = 426
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_SEC_427(game):
    cid = 427
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_R__428(game):
    cid = 428
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P_429(game):
    cid = 429
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_007_P__430(game):
    cid = 430
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_008_P_431(game):
    cid = 431
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_008_R_432(game):
    cid = 432
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_008_R_433(game):
    cid = 433
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_008_P_434(game):
    cid = 434
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_009_P_435(game):
    cid = 435
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_009_R_436(game):
    cid = 436
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_009_R_437(game):
    cid = 437
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_009_P_438(game):
    cid = 438
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 32, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_010_N_439(game):
    cid = 439
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_011_N_440(game):
    cid = 440
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_011_PR_441(game):
    cid = 441
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_011_PR_442(game):
    cid = 442
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_011_N_443(game):
    cid = 443
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_012_N_444(game):
    cid = 444
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_013_N_445(game):
    cid = 445
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_014_N_446(game):
    cid = 446
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_015_N_447(game):
    cid = 447
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_HS_bp2_016_N_448(game):
    cid = 448
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_017_N_449(game):
    cid = 449
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_018_N_450(game):
    cid = 450
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_PR_003_PR_451(game):
    cid = 451
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 18, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_004_PR_452(game):
    cid = 452
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_005_PR_453(game):
    cid = 453
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_PR_006_PR_454(game):
    cid = 454
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_007_PR_455(game):
    cid = 455
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_PR_008_PR_456(game):
    cid = 456
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 18, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_009_PR_457(game):
    cid = 457
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_PR_010_PR_458(game):
    cid = 458
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 18, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_011_PR_459(game):
    cid = 459
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_PR_012_PR_460(game):
    cid = 460
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_PR_013_PR_461(game):
    cid = 461
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_PR_014_PR_462(game):
    cid = 462
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_001_P_463(game):
    cid = 463
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_001_R_464(game):
    cid = 464
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_001_R_465(game):
    cid = 465
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_001_P_466(game):
    cid = 466
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P_467(game):
    cid = 467
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_R__468(game):
    cid = 468
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P__469(game):
    cid = 469
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_SEC_470(game):
    cid = 470
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P__471(game):
    cid = 471
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_R__472(game):
    cid = 472
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P_473(game):
    cid = 473
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_SEC_474(game):
    cid = 474
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_R__475(game):
    cid = 475
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P_476(game):
    cid = 476
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P__477(game):
    cid = 477
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_SEC_478(game):
    cid = 478
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_SEC_479(game):
    cid = 479
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_R__480(game):
    cid = 480
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P_481(game):
    cid = 481
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_002_P__482(game):
    cid = 482
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_003_P_483(game):
    cid = 483
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_R__484(game):
    cid = 484
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P__485(game):
    cid = 485
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_SEC_486(game):
    cid = 486
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P__487(game):
    cid = 487
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_R__488(game):
    cid = 488
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P_489(game):
    cid = 489
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_SEC_490(game):
    cid = 490
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_R__491(game):
    cid = 491
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P_492(game):
    cid = 492
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P__493(game):
    cid = 493
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_SEC_494(game):
    cid = 494
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_SEC_495(game):
    cid = 495
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_R__496(game):
    cid = 496
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P_497(game):
    cid = 497
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_003_P__498(game):
    cid = 498
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp1_004_P_499(game):
    cid = 499
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_004_R_500(game):
    cid = 500
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_004_R_501(game):
    cid = 501
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_004_P_502(game):
    cid = 502
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_005_P_503(game):
    cid = 503
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_005_R_504(game):
    cid = 504
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_005_R_505(game):
    cid = 505
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_005_P_506(game):
    cid = 506
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P_507(game):
    cid = 507
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_R__508(game):
    cid = 508
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P__509(game):
    cid = 509
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_SEC_510(game):
    cid = 510
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P__511(game):
    cid = 511
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_R__512(game):
    cid = 512
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P_513(game):
    cid = 513
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_SEC_514(game):
    cid = 514
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_R__515(game):
    cid = 515
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P_516(game):
    cid = 516
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P__517(game):
    cid = 517
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_SEC_518(game):
    cid = 518
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_SEC_519(game):
    cid = 519
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_R__520(game):
    cid = 520
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P_521(game):
    cid = 521
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_006_P__522(game):
    cid = 522
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_007_P_523(game):
    cid = 523
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_007_R_524(game):
    cid = 524
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_007_R_525(game):
    cid = 525
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_007_P_526(game):
    cid = 526
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_008_P_527(game):
    cid = 527
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_008_R_528(game):
    cid = 528
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_008_R_529(game):
    cid = 529
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_008_P_530(game):
    cid = 530
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_009_P_531(game):
    cid = 531
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_009_R_532(game):
    cid = 532
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_009_R_533(game):
    cid = 533
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_009_P_534(game):
    cid = 534
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_010_P_535(game):
    cid = 535
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_010_R_536(game):
    cid = 536
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_010_R_537(game):
    cid = 537
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_010_P_538(game):
    cid = 538
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_011_P_539(game):
    cid = 539
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_011_R_540(game):
    cid = 540
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_011_R_541(game):
    cid = 541
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_011_P_542(game):
    cid = 542
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P_543(game):
    cid = 543
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_R__544(game):
    cid = 544
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P__545(game):
    cid = 545
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_SEC_546(game):
    cid = 546
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P__547(game):
    cid = 547
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_R__548(game):
    cid = 548
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P_549(game):
    cid = 549
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_SEC_550(game):
    cid = 550
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_R__551(game):
    cid = 551
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P_552(game):
    cid = 552
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P__553(game):
    cid = 553
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_SEC_554(game):
    cid = 554
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_SEC_555(game):
    cid = 555
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_R__556(game):
    cid = 556
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P_557(game):
    cid = 557
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_012_P__558(game):
    cid = 558
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_013_N_559(game):
    cid = 559
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_014_N_560(game):
    cid = 560
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_015_N_561(game):
    cid = 561
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_016_N_562(game):
    cid = 562
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_017_N_563(game):
    cid = 563
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_018_N_564(game):
    cid = 564
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_019_N_565(game):
    cid = 565
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_019_PR_566(game):
    cid = 566
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_019_PR_567(game):
    cid = 567
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_019_N_568(game):
    cid = 568
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp1_020_N_569(game):
    cid = 569
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_021_N_570(game):
    cid = 570
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_022_N_571(game):
    cid = 571
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_023_N_572(game):
    cid = 572
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_024_N_573(game):
    cid = 573
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_001_P_574(game):
    cid = 574
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_R__575(game):
    cid = 575
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P__576(game):
    cid = 576
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_SEC_577(game):
    cid = 577
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P__578(game):
    cid = 578
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_R__579(game):
    cid = 579
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P_580(game):
    cid = 580
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_SEC_581(game):
    cid = 581
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_R__582(game):
    cid = 582
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P_583(game):
    cid = 583
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P__584(game):
    cid = 584
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_SEC_585(game):
    cid = 585
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_SEC_586(game):
    cid = 586
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_R__587(game):
    cid = 587
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P_588(game):
    cid = 588
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_001_P__589(game):
    cid = 589
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_002_P_590(game):
    cid = 590
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp3_002_R_591(game):
    cid = 591
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp3_002_R_592(game):
    cid = 592
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp3_002_P_593(game):
    cid = 593
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp3_003_P_594(game):
    cid = 594
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_003_R_595(game):
    cid = 595
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_003_R_596(game):
    cid = 596
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_003_P_597(game):
    cid = 597
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_004_P_598(game):
    cid = 598
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_004_R_599(game):
    cid = 599
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_004_R_600(game):
    cid = 600
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_004_P_601(game):
    cid = 601
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P_602(game):
    cid = 602
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_R__603(game):
    cid = 603
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P__604(game):
    cid = 604
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_SEC_605(game):
    cid = 605
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P__606(game):
    cid = 606
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_R__607(game):
    cid = 607
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P_608(game):
    cid = 608
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_SEC_609(game):
    cid = 609
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_R__610(game):
    cid = 610
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P_611(game):
    cid = 611
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P__612(game):
    cid = 612
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_SEC_613(game):
    cid = 613
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_SEC_614(game):
    cid = 614
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_R__615(game):
    cid = 615
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P_616(game):
    cid = 616
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_005_P__617(game):
    cid = 617
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_006_P_618(game):
    cid = 618
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_006_R_619(game):
    cid = 619
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_006_R_620(game):
    cid = 620
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_006_P_621(game):
    cid = 621
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_007_P_622(game):
    cid = 622
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_007_R_623(game):
    cid = 623
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_007_R_624(game):
    cid = 624
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_007_P_625(game):
    cid = 625
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P_626(game):
    cid = 626
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_R__627(game):
    cid = 627
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P__628(game):
    cid = 628
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_SEC_629(game):
    cid = 629
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P__630(game):
    cid = 630
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_R__631(game):
    cid = 631
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P_632(game):
    cid = 632
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_SEC_633(game):
    cid = 633
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_R__634(game):
    cid = 634
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P_635(game):
    cid = 635
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P__636(game):
    cid = 636
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_SEC_637(game):
    cid = 637
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_SEC_638(game):
    cid = 638
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_R__639(game):
    cid = 639
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P_640(game):
    cid = 640
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_008_P__641(game):
    cid = 641
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_009_P_642(game):
    cid = 642
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_R__643(game):
    cid = 643
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P__644(game):
    cid = 644
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_SEC_645(game):
    cid = 645
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P__646(game):
    cid = 646
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_R__647(game):
    cid = 647
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P_648(game):
    cid = 648
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_SEC_649(game):
    cid = 649
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_R__650(game):
    cid = 650
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P_651(game):
    cid = 651
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P__652(game):
    cid = 652
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_SEC_653(game):
    cid = 653
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_SEC_654(game):
    cid = 654
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_R__655(game):
    cid = 655
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P_656(game):
    cid = 656
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_009_P__657(game):
    cid = 657
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_010_P_658(game):
    cid = 658
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_010_R_659(game):
    cid = 659
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_010_R_660(game):
    cid = 660
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_010_P_661(game):
    cid = 661
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_011_P_662(game):
    cid = 662
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 4, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 1, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL_N_bp3_011_R_663(game):
    cid = 663
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 4, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 1, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL_N_bp3_011_R_664(game):
    cid = 664
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 4, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 1, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL_N_bp3_011_P_665(game):
    cid = 665
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 4, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 1, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL_N_bp3_012_P_666(game):
    cid = 666
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_012_R_667(game):
    cid = 667
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_012_R_668(game):
    cid = 668
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_012_P_669(game):
    cid = 669
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_013_N_670(game):
    cid = 670
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_014_N_671(game):
    cid = 671
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_015_N_672(game):
    cid = 672
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_016_N_673(game):
    cid = 673
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_017_N_674(game):
    cid = 674
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_018_N_675(game):
    cid = 675
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_019_N_676(game):
    cid = 676
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_020_N_677(game):
    cid = 677
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_021_N_678(game):
    cid = 678
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_022_N_679(game):
    cid = 679
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_023_N_680(game):
    cid = 680
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_024_N_681(game):
    cid = 681
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_001_P_682(game):
    cid = 682
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_001_R_683(game):
    cid = 683
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_001_R_684(game):
    cid = 684
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_001_P_685(game):
    cid = 685
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_002_P_686(game):
    cid = 686
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 27, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_002_R_687(game):
    cid = 687
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 27, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_002_R_688(game):
    cid = 688
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 27, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_002_P_689(game):
    cid = 689
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 27, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_003_P_690(game):
    cid = 690
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_003_R_691(game):
    cid = 691
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_003_R_692(game):
    cid = 692
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_003_P_693(game):
    cid = 693
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_004_P_694(game):
    cid = 694
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_R__695(game):
    cid = 695
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P__696(game):
    cid = 696
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_SEC_697(game):
    cid = 697
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P__698(game):
    cid = 698
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_R__699(game):
    cid = 699
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P_700(game):
    cid = 700
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_SEC_701(game):
    cid = 701
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_R__702(game):
    cid = 702
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P_703(game):
    cid = 703
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P__704(game):
    cid = 704
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_SEC_705(game):
    cid = 705
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_SEC_706(game):
    cid = 706
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_R__707(game):
    cid = 707
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P_708(game):
    cid = 708
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_004_P__709(game):
    cid = 709
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 19, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp4_005_P_710(game):
    cid = 710
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_005_R_711(game):
    cid = 711
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_005_R_712(game):
    cid = 712
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_005_P_713(game):
    cid = 713
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_006_P_714(game):
    cid = 714
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 40, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_006_R_715(game):
    cid = 715
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 40, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_006_R_716(game):
    cid = 716
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 40, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_006_P_717(game):
    cid = 717
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 40, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P_718(game):
    cid = 718
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_R__719(game):
    cid = 719
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P__720(game):
    cid = 720
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_SEC_721(game):
    cid = 721
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P__722(game):
    cid = 722
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_R__723(game):
    cid = 723
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P_724(game):
    cid = 724
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_SEC_725(game):
    cid = 725
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_R__726(game):
    cid = 726
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P_727(game):
    cid = 727
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P__728(game):
    cid = 728
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_SEC_729(game):
    cid = 729
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_SEC_730(game):
    cid = 730
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_R__731(game):
    cid = 731
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P_732(game):
    cid = 732
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_007_P__733(game):
    cid = 733
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 3, f"Trigger mismatch: {ab2.trigger} != 3"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_008_P_734(game):
    cid = 734
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_008_R_735(game):
    cid = 735
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_008_R_736(game):
    cid = 736
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_008_P_737(game):
    cid = 737
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_009_P_738(game):
    cid = 738
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_009_R_739(game):
    cid = 739
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_009_R_740(game):
    cid = 740
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_009_P_741(game):
    cid = 741
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P_742(game):
    cid = 742
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_R__743(game):
    cid = 743
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P__744(game):
    cid = 744
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_SEC_745(game):
    cid = 745
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P__746(game):
    cid = 746
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_R__747(game):
    cid = 747
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P_748(game):
    cid = 748
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_SEC_749(game):
    cid = 749
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_R__750(game):
    cid = 750
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P_751(game):
    cid = 751
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P__752(game):
    cid = 752
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_SEC_753(game):
    cid = 753
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_SEC_754(game):
    cid = 754
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_R__755(game):
    cid = 755
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P_756(game):
    cid = 756
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_010_P__757(game):
    cid = 757
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P_758(game):
    cid = 758
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_R__759(game):
    cid = 759
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P__760(game):
    cid = 760
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_SEC_761(game):
    cid = 761
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P__762(game):
    cid = 762
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_R__763(game):
    cid = 763
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P_764(game):
    cid = 764
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_SEC_765(game):
    cid = 765
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_R__766(game):
    cid = 766
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P_767(game):
    cid = 767
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P__768(game):
    cid = 768
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_SEC_769(game):
    cid = 769
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_SEC_770(game):
    cid = 770
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_R__771(game):
    cid = 771
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P_772(game):
    cid = 772
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_011_P__773(game):
    cid = 773
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 5, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_012_P_774(game):
    cid = 774
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_012_R_775(game):
    cid = 775
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_012_R_776(game):
    cid = 776
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_012_P_777(game):
    cid = 777
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_013_N_778(game):
    cid = 778
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_014_N_779(game):
    cid = 779
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_015_N_780(game):
    cid = 780
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_016_N_781(game):
    cid = 781
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_017_N_782(game):
    cid = 782
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_018_N_783(game):
    cid = 783
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_019_N_784(game):
    cid = 784
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_020_N_785(game):
    cid = 785
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_021_N_786(game):
    cid = 786
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_022_N_787(game):
    cid = 787
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_023_N_788(game):
    cid = 788
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_024_N_789(game):
    cid = 789
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_001_P__790(game):
    cid = 790
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_001_R_791(game):
    cid = 791
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_001_R_792(game):
    cid = 792
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_001_P__793(game):
    cid = 793
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_002_P__794(game):
    cid = 794
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_002_R_795(game):
    cid = 795
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_002_R_796(game):
    cid = 796
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_002_P__797(game):
    cid = 797
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_003_P__798(game):
    cid = 798
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_003_R_799(game):
    cid = 799
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_003_R_800(game):
    cid = 800
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_003_P__801(game):
    cid = 801
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_004_P__802(game):
    cid = 802
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_pb1_004_R_803(game):
    cid = 803
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_pb1_004_R_804(game):
    cid = 804
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_pb1_004_P__805(game):
    cid = 805
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab1.effects) == 3, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 26, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 7, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab1.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab1.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_pb1_005_P__806(game):
    cid = 806
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_005_R_807(game):
    cid = 807
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_005_R_808(game):
    cid = 808
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_005_P__809(game):
    cid = 809
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_006_P__810(game):
    cid = 810
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_006_R_811(game):
    cid = 811
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_006_R_812(game):
    cid = 812
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_006_P__813(game):
    cid = 813
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_007_P__814(game):
    cid = 814
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_007_R_815(game):
    cid = 815
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_007_R_816(game):
    cid = 816
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_007_P__817(game):
    cid = 817
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_008_P__818(game):
    cid = 818
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_008_R_819(game):
    cid = 819
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_008_R_820(game):
    cid = 820
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_008_P__821(game):
    cid = 821
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_009_P__822(game):
    cid = 822
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_009_R_823(game):
    cid = 823
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_009_R_824(game):
    cid = 824
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_009_P__825(game):
    cid = 825
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 2, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_010_P__826(game):
    cid = 826
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_010_R_827(game):
    cid = 827
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_010_R_828(game):
    cid = 828
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_010_P__829(game):
    cid = 829
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_011_P__830(game):
    cid = 830
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_011_R_831(game):
    cid = 831
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_011_R_832(game):
    cid = 832
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_011_P__833(game):
    cid = 833
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_012_P__834(game):
    cid = 834
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 3, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert ab0.conditions[2].type == 0, "Condition 2 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_012_R_835(game):
    cid = 835
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 3, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert ab0.conditions[2].type == 0, "Condition 2 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_012_R_836(game):
    cid = 836
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 3, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert ab0.conditions[2].type == 0, "Condition 2 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_012_P__837(game):
    cid = 837
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 3, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert ab0.conditions[2].type == 0, "Condition 2 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_013_P__838(game):
    cid = 838
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_013_R_839(game):
    cid = 839
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_013_R_840(game):
    cid = 840
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_013_P__841(game):
    cid = 841
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_014_P__842(game):
    cid = 842
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_014_R_843(game):
    cid = 843
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_014_R_844(game):
    cid = 844
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_014_P__845(game):
    cid = 845
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_015_P__846(game):
    cid = 846
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_015_R_847(game):
    cid = 847
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_015_R_848(game):
    cid = 848
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_015_P__849(game):
    cid = 849
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_016_P__850(game):
    cid = 850
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_016_R_851(game):
    cid = 851
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_016_R_852(game):
    cid = 852
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_016_P__853(game):
    cid = 853
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_017_P__854(game):
    cid = 854
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_017_R_855(game):
    cid = 855
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_017_R_856(game):
    cid = 856
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_017_P__857(game):
    cid = 857
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_018_P__858(game):
    cid = 858
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_018_R_859(game):
    cid = 859
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_018_R_860(game):
    cid = 860
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_018_P__861(game):
    cid = 861
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_019_P__862(game):
    cid = 862
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_019_R_863(game):
    cid = 863
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_019_R_864(game):
    cid = 864
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_019_P__865(game):
    cid = 865
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_020_P__866(game):
    cid = 866
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_020_R_867(game):
    cid = 867
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_020_R_868(game):
    cid = 868
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_020_P__869(game):
    cid = 869
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_021_P__870(game):
    cid = 870
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_021_R_871(game):
    cid = 871
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_021_R_872(game):
    cid = 872
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_021_P__873(game):
    cid = 873
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_022_P__874(game):
    cid = 874
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_022_R_875(game):
    cid = 875
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_022_R_876(game):
    cid = 876
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_022_P__877(game):
    cid = 877
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_023_P__878(game):
    cid = 878
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_023_R_879(game):
    cid = 879
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_023_R_880(game):
    cid = 880
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_023_P__881(game):
    cid = 881
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_024_P__882(game):
    cid = 882
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_024_R_883(game):
    cid = 883
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_024_R_884(game):
    cid = 884
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_024_P__885(game):
    cid = 885
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_025_N_886(game):
    cid = 886
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_026_N_887(game):
    cid = 887
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_027_N_888(game):
    cid = 888
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_028_N_889(game):
    cid = 889
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_029_N_890(game):
    cid = 890
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_030_N_891(game):
    cid = 891
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_031_N_892(game):
    cid = 892
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_032_N_893(game):
    cid = 893
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_033_N_894(game):
    cid = 894
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_034_N_895(game):
    cid = 895
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_035_N_896(game):
    cid = 896
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_036_N_897(game):
    cid = 897
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 22, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_001_SD_898(game):
    cid = 898
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_002_SD_899(game):
    cid = 899
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_003_SD_900(game):
    cid = 900
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_004_SD_901(game):
    cid = 901
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_005_SD_902(game):
    cid = 902
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_006_SD_903(game):
    cid = 903
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_007_SD_904(game):
    cid = 904
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_008_SD_905(game):
    cid = 905
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_009_SD_906(game):
    cid = 906
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_010_SD_907(game):
    cid = 907
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_011_SD_908(game):
    cid = 908
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_sd1_012_SD_909(game):
    cid = 909
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_013_SD_910(game):
    cid = 910
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_014_SD_911(game):
    cid = 911
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_015_SD_912(game):
    cid = 912
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_016_SD_913(game):
    cid = 913
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_017_SD_914(game):
    cid = 914
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_018_SD_915(game):
    cid = 915
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_019_SD_916(game):
    cid = 916
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_020_SD_917(game):
    cid = 917
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_021_SD_918(game):
    cid = 918
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_022_SD_919(game):
    cid = 919
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_sd1_023_SD_920(game):
    cid = 920
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_024_SD_921(game):
    cid = 921
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_013_PR_922(game):
    cid = 922
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_014_PR_923(game):
    cid = 923
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_015_PR_924(game):
    cid = 924
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_016_PR_925(game):
    cid = 925
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_017_PR_926(game):
    cid = 926
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_018_PR_927(game):
    cid = 927
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_019_PR_928(game):
    cid = 928
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_020_PR_929(game):
    cid = 929
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_021_PR_930(game):
    cid = 930
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_025_PR_931(game):
    cid = 931
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_PR_026_PR_932(game):
    cid = 932
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_PR_027_PR_933(game):
    cid = 933
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_PR_028_PR_934(game):
    cid = 934
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_PR_029_PR_935(game):
    cid = 935
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_030_PR_936(game):
    cid = 936
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_031_PR_937(game):
    cid = 937
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_PR_032_PR_938(game):
    cid = 938
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_PR_033_PR_939(game):
    cid = 939
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_001_P_940(game):
    cid = 940
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_001_R_941(game):
    cid = 941
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_001_R_942(game):
    cid = 942
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_001_P_943(game):
    cid = 943
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 8, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_002_P_944(game):
    cid = 944
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_002_R_945(game):
    cid = 945
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_002_R_946(game):
    cid = 946
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_002_P_947(game):
    cid = 947
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 5, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_003_P_948(game):
    cid = 948
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_003_R_949(game):
    cid = 949
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_003_R_950(game):
    cid = 950
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_003_P_951(game):
    cid = 951
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_004_P_952(game):
    cid = 952
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_004_R_953(game):
    cid = 953
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_004_R_954(game):
    cid = 954
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_004_P_955(game):
    cid = 955
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_005_P_956(game):
    cid = 956
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_R__957(game):
    cid = 957
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P__958(game):
    cid = 958
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_SEC_959(game):
    cid = 959
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P__960(game):
    cid = 960
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_R__961(game):
    cid = 961
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P_962(game):
    cid = 962
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_SEC_963(game):
    cid = 963
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_R__964(game):
    cid = 964
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P_965(game):
    cid = 965
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P__966(game):
    cid = 966
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_SEC_967(game):
    cid = 967
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_SEC_968(game):
    cid = 968
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_R__969(game):
    cid = 969
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P_970(game):
    cid = 970
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_005_P__971(game):
    cid = 971
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_006_P_972(game):
    cid = 972
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_006_R_973(game):
    cid = 973
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_006_R_974(game):
    cid = 974
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_006_P_975(game):
    cid = 975
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_007_P_976(game):
    cid = 976
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_R__977(game):
    cid = 977
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P__978(game):
    cid = 978
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_SEC_979(game):
    cid = 979
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P__980(game):
    cid = 980
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_R__981(game):
    cid = 981
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P_982(game):
    cid = 982
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_SEC_983(game):
    cid = 983
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_R__984(game):
    cid = 984
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P_985(game):
    cid = 985
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P__986(game):
    cid = 986
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_SEC_987(game):
    cid = 987
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_SEC_988(game):
    cid = 988
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_R__989(game):
    cid = 989
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P_990(game):
    cid = 990
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_007_P__991(game):
    cid = 991
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 8, f"Trigger mismatch: {ab0.trigger} != 8"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_008_P_992(game):
    cid = 992
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_R__993(game):
    cid = 993
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P__994(game):
    cid = 994
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_SEC_995(game):
    cid = 995
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P__996(game):
    cid = 996
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_R__997(game):
    cid = 997
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P_998(game):
    cid = 998
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_SEC_999(game):
    cid = 999
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_R__1000(game):
    cid = 1000
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P_1001(game):
    cid = 1001
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P__1002(game):
    cid = 1002
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_SEC_1003(game):
    cid = 1003
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_SEC_1004(game):
    cid = 1004
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_R__1005(game):
    cid = 1005
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P_1006(game):
    cid = 1006
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_008_P__1007(game):
    cid = 1007
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 6, f"Trigger mismatch: {ab2.trigger} != 6"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 2, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab2.effects[1].effect_type == 8, "Effect 1 type mismatch"
    assert ab2.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_009_P_1008(game):
    cid = 1008
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_009_R_1009(game):
    cid = 1009
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_009_R_1010(game):
    cid = 1010
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_009_P_1011(game):
    cid = 1011
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_010_N_1012(game):
    cid = 1012
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 11, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_011_N_1013(game):
    cid = 1013
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_012_N_1014(game):
    cid = 1014
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_013_N_1015(game):
    cid = 1015
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_014_N_1016(game):
    cid = 1016
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_015_N_1017(game):
    cid = 1017
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_016_N_1018(game):
    cid = 1018
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_017_N_1019(game):
    cid = 1019
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_018_N_1020(game):
    cid = 1020
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_001_P_1021(game):
    cid = 1021
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_R__1022(game):
    cid = 1022
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P__1023(game):
    cid = 1023
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_SEC_1024(game):
    cid = 1024
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P__1025(game):
    cid = 1025
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_R__1026(game):
    cid = 1026
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P_1027(game):
    cid = 1027
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_SEC_1028(game):
    cid = 1028
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_R__1029(game):
    cid = 1029
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P_1030(game):
    cid = 1030
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P__1031(game):
    cid = 1031
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_SEC_1032(game):
    cid = 1032
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_SEC_1033(game):
    cid = 1033
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_R__1034(game):
    cid = 1034
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P_1035(game):
    cid = 1035
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_001_P__1036(game):
    cid = 1036
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_bp3_002_P_1037(game):
    cid = 1037
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_002_R_1038(game):
    cid = 1038
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_002_R_1039(game):
    cid = 1039
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_002_P_1040(game):
    cid = 1040
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P_1041(game):
    cid = 1041
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_R__1042(game):
    cid = 1042
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P__1043(game):
    cid = 1043
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_SEC_1044(game):
    cid = 1044
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P__1045(game):
    cid = 1045
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_R__1046(game):
    cid = 1046
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P_1047(game):
    cid = 1047
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_SEC_1048(game):
    cid = 1048
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_R__1049(game):
    cid = 1049
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P_1050(game):
    cid = 1050
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P__1051(game):
    cid = 1051
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_SEC_1052(game):
    cid = 1052
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_SEC_1053(game):
    cid = 1053
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_R__1054(game):
    cid = 1054
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P_1055(game):
    cid = 1055
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_003_P__1056(game):
    cid = 1056
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_004_P_1057(game):
    cid = 1057
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_004_R_1058(game):
    cid = 1058
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_004_R_1059(game):
    cid = 1059
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_004_P_1060(game):
    cid = 1060
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_005_P_1061(game):
    cid = 1061
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_005_R_1062(game):
    cid = 1062
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_005_R_1063(game):
    cid = 1063
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_005_P_1064(game):
    cid = 1064
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_006_P_1065(game):
    cid = 1065
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_R__1066(game):
    cid = 1066
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P__1067(game):
    cid = 1067
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_SEC_1068(game):
    cid = 1068
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P__1069(game):
    cid = 1069
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_R__1070(game):
    cid = 1070
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P_1071(game):
    cid = 1071
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_SEC_1072(game):
    cid = 1072
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_R__1073(game):
    cid = 1073
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P_1074(game):
    cid = 1074
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P__1075(game):
    cid = 1075
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_SEC_1076(game):
    cid = 1076
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_SEC_1077(game):
    cid = 1077
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_R__1078(game):
    cid = 1078
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P_1079(game):
    cid = 1079
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_006_P__1080(game):
    cid = 1080
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 1, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_007_P_1081(game):
    cid = 1081
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_bp3_007_R_1082(game):
    cid = 1082
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_bp3_007_R_1083(game):
    cid = 1083
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_bp3_007_P_1084(game):
    cid = 1084
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_bp3_008_P_1085(game):
    cid = 1085
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 4, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_008_R_1086(game):
    cid = 1086
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 4, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_008_R_1087(game):
    cid = 1087
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 4, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_008_P_1088(game):
    cid = 1088
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 4, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_009_P_1089(game):
    cid = 1089
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_009_R_1090(game):
    cid = 1090
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_009_R_1091(game):
    cid = 1091
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_009_P_1092(game):
    cid = 1092
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_010_N_1093(game):
    cid = 1093
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_011_N_1094(game):
    cid = 1094
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_012_N_1095(game):
    cid = 1095
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_013_N_1096(game):
    cid = 1096
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_014_N_1097(game):
    cid = 1097
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_015_N_1098(game):
    cid = 1098
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_016_N_1099(game):
    cid = 1099
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 3, "Effect 0 type mismatch"
    assert ab0.effects[0].value == -1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_017_N_1100(game):
    cid = 1100
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_018_N_1101(game):
    cid = 1101
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_001_P__1102(game):
    cid = 1102
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_001_R_1103(game):
    cid = 1103
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_001_R_1104(game):
    cid = 1104
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_001_P__1105(game):
    cid = 1105
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_002_P__1106(game):
    cid = 1106
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_pb1_002_R_1107(game):
    cid = 1107
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_pb1_002_R_1108(game):
    cid = 1108
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_pb1_002_P__1109(game):
    cid = 1109
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_S_pb1_003_P__1110(game):
    cid = 1110
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_003_R_1111(game):
    cid = 1111
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_003_R_1112(game):
    cid = 1112
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_003_P__1113(game):
    cid = 1113
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_004_P__1114(game):
    cid = 1114
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_004_R_1115(game):
    cid = 1115
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_004_R_1116(game):
    cid = 1116
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_004_P__1117(game):
    cid = 1117
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_005_P__1118(game):
    cid = 1118
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_005_R_1119(game):
    cid = 1119
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_005_R_1120(game):
    cid = 1120
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_005_P__1121(game):
    cid = 1121
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_006_P__1122(game):
    cid = 1122
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_006_R_1123(game):
    cid = 1123
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_006_R_1124(game):
    cid = 1124
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_006_P__1125(game):
    cid = 1125
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_007_P__1126(game):
    cid = 1126
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_007_R_1127(game):
    cid = 1127
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_007_R_1128(game):
    cid = 1128
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_007_P__1129(game):
    cid = 1129
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_008_P__1130(game):
    cid = 1130
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_pb1_008_R_1131(game):
    cid = 1131
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_pb1_008_R_1132(game):
    cid = 1132
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_pb1_008_P__1133(game):
    cid = 1133
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 4, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_pb1_009_P__1134(game):
    cid = 1134
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_009_R_1135(game):
    cid = 1135
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_009_R_1136(game):
    cid = 1136
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_009_P__1137(game):
    cid = 1137
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_010_N_1138(game):
    cid = 1138
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_011_N_1139(game):
    cid = 1139
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_012_N_1140(game):
    cid = 1140
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_013_N_1141(game):
    cid = 1141
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_014_N_1142(game):
    cid = 1142
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_015_N_1143(game):
    cid = 1143
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_016_N_1144(game):
    cid = 1144
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_017_N_1145(game):
    cid = 1145
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_018_N_1146(game):
    cid = 1146
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_003_PR_1147(game):
    cid = 1147
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_004_PR_1148(game):
    cid = 1148
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_005_PR_1149(game):
    cid = 1149
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_006_PR_1150(game):
    cid = 1150
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_007_PR_1151(game):
    cid = 1151
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_008_PR_1152(game):
    cid = 1152
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_009_PR_1153(game):
    cid = 1153
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_PR_010_PR_1154(game):
    cid = 1154
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_PR_011_PR_1155(game):
    cid = 1155
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_PR_012_PR_1156(game):
    cid = 1156
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_PR_013_PR_1157(game):
    cid = 1157
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_001_P_1158(game):
    cid = 1158
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_001_R_1159(game):
    cid = 1159
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_001_R_1160(game):
    cid = 1160
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_001_P_1161(game):
    cid = 1161
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P_1162(game):
    cid = 1162
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_R__1163(game):
    cid = 1163
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P__1164(game):
    cid = 1164
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_SEC_1165(game):
    cid = 1165
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P__1166(game):
    cid = 1166
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_R__1167(game):
    cid = 1167
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P_1168(game):
    cid = 1168
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_SEC_1169(game):
    cid = 1169
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_R__1170(game):
    cid = 1170
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P_1171(game):
    cid = 1171
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P__1172(game):
    cid = 1172
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_SEC_1173(game):
    cid = 1173
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_SEC_1174(game):
    cid = 1174
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_R__1175(game):
    cid = 1175
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P_1176(game):
    cid = 1176
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_002_P__1177(game):
    cid = 1177
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_003_P_1178(game):
    cid = 1178
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_R__1179(game):
    cid = 1179
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P__1180(game):
    cid = 1180
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_SEC_1181(game):
    cid = 1181
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P__1182(game):
    cid = 1182
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_R__1183(game):
    cid = 1183
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P_1184(game):
    cid = 1184
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_SEC_1185(game):
    cid = 1185
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_R__1186(game):
    cid = 1186
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P_1187(game):
    cid = 1187
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P__1188(game):
    cid = 1188
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_SEC_1189(game):
    cid = 1189
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_SEC_1190(game):
    cid = 1190
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_R__1191(game):
    cid = 1191
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P_1192(game):
    cid = 1192
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_003_P__1193(game):
    cid = 1193
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_004_P_1194(game):
    cid = 1194
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_004_R_1195(game):
    cid = 1195
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_004_R_1196(game):
    cid = 1196
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_004_P_1197(game):
    cid = 1197
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_005_P_1198(game):
    cid = 1198
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_005_R_1199(game):
    cid = 1199
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_005_R_1200(game):
    cid = 1200
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_005_P_1201(game):
    cid = 1201
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_006_P_1202(game):
    cid = 1202
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_006_R_1203(game):
    cid = 1203
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_006_R_1204(game):
    cid = 1204
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_006_P_1205(game):
    cid = 1205
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P_1206(game):
    cid = 1206
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_R__1207(game):
    cid = 1207
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P__1208(game):
    cid = 1208
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_SEC_1209(game):
    cid = 1209
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P__1210(game):
    cid = 1210
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_R__1211(game):
    cid = 1211
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P_1212(game):
    cid = 1212
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_SEC_1213(game):
    cid = 1213
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_R__1214(game):
    cid = 1214
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P_1215(game):
    cid = 1215
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P__1216(game):
    cid = 1216
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_SEC_1217(game):
    cid = 1217
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_SEC_1218(game):
    cid = 1218
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_R__1219(game):
    cid = 1219
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P_1220(game):
    cid = 1220
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_007_P__1221(game):
    cid = 1221
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_008_P_1222(game):
    cid = 1222
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_008_R_1223(game):
    cid = 1223
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_008_R_1224(game):
    cid = 1224
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_008_P_1225(game):
    cid = 1225
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_009_P_1226(game):
    cid = 1226
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_009_R_1227(game):
    cid = 1227
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_009_R_1228(game):
    cid = 1228
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_009_P_1229(game):
    cid = 1229
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_010_P_1230(game):
    cid = 1230
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_010_R_1231(game):
    cid = 1231
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_010_R_1232(game):
    cid = 1232
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_010_P_1233(game):
    cid = 1233
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_011_P_1234(game):
    cid = 1234
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_011_R_1235(game):
    cid = 1235
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_011_R_1236(game):
    cid = 1236
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_011_P_1237(game):
    cid = 1237
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_012_N_1238(game):
    cid = 1238
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_013_N_1239(game):
    cid = 1239
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_013_PR_1240(game):
    cid = 1240
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_013_PR_1241(game):
    cid = 1241
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_013_N_1242(game):
    cid = 1242
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_014_N_1243(game):
    cid = 1243
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_015_N_1244(game):
    cid = 1244
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_016_N_1245(game):
    cid = 1245
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_017_N_1246(game):
    cid = 1246
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_018_N_1247(game):
    cid = 1247
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_019_N_1248(game):
    cid = 1248
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_020_N_1249(game):
    cid = 1249
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_021_N_1250(game):
    cid = 1250
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_022_N_1251(game):
    cid = 1251
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_001_P_1252(game):
    cid = 1252
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_R__1253(game):
    cid = 1253
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P__1254(game):
    cid = 1254
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_SEC_1255(game):
    cid = 1255
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P__1256(game):
    cid = 1256
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_R__1257(game):
    cid = 1257
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P_1258(game):
    cid = 1258
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_SEC_1259(game):
    cid = 1259
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_R__1260(game):
    cid = 1260
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P_1261(game):
    cid = 1261
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P__1262(game):
    cid = 1262
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_SEC_1263(game):
    cid = 1263
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_SEC_1264(game):
    cid = 1264
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_R__1265(game):
    cid = 1265
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P_1266(game):
    cid = 1266
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_001_P__1267(game):
    cid = 1267
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 14, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 7, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_002_P_1268(game):
    cid = 1268
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_002_R_1269(game):
    cid = 1269
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_002_R_1270(game):
    cid = 1270
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_002_P_1271(game):
    cid = 1271
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_003_P_1272(game):
    cid = 1272
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_003_R_1273(game):
    cid = 1273
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_003_R_1274(game):
    cid = 1274
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_003_P_1275(game):
    cid = 1275
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_004_P_1276(game):
    cid = 1276
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_004_R_1277(game):
    cid = 1277
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_004_R_1278(game):
    cid = 1278
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_004_P_1279(game):
    cid = 1279
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 7, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_005_P_1280(game):
    cid = 1280
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_005_R_1281(game):
    cid = 1281
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_005_R_1282(game):
    cid = 1282
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_005_P_1283(game):
    cid = 1283
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P_1284(game):
    cid = 1284
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_R__1285(game):
    cid = 1285
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P__1286(game):
    cid = 1286
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_SEC_1287(game):
    cid = 1287
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P__1288(game):
    cid = 1288
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_R__1289(game):
    cid = 1289
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P_1290(game):
    cid = 1290
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_SEC_1291(game):
    cid = 1291
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_R__1292(game):
    cid = 1292
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P_1293(game):
    cid = 1293
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P__1294(game):
    cid = 1294
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_SEC_1295(game):
    cid = 1295
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_SEC_1296(game):
    cid = 1296
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_R__1297(game):
    cid = 1297
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P_1298(game):
    cid = 1298
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_006_P__1299(game):
    cid = 1299
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 7, f"Trigger mismatch: {ab1.trigger} != 7"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 35, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_007_P_1300(game):
    cid = 1300
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_007_R_1301(game):
    cid = 1301
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_007_R_1302(game):
    cid = 1302
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_007_P_1303(game):
    cid = 1303
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_008_P_1304(game):
    cid = 1304
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_008_R_1305(game):
    cid = 1305
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_008_R_1306(game):
    cid = 1306
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_008_P_1307(game):
    cid = 1307
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_009_P_1308(game):
    cid = 1308
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_R__1309(game):
    cid = 1309
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P__1310(game):
    cid = 1310
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_SEC_1311(game):
    cid = 1311
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P__1312(game):
    cid = 1312
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_R__1313(game):
    cid = 1313
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P_1314(game):
    cid = 1314
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_SEC_1315(game):
    cid = 1315
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_R__1316(game):
    cid = 1316
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P_1317(game):
    cid = 1317
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P__1318(game):
    cid = 1318
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_SEC_1319(game):
    cid = 1319
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_SEC_1320(game):
    cid = 1320
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_R__1321(game):
    cid = 1321
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P_1322(game):
    cid = 1322
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_009_P__1323(game):
    cid = 1323
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp2_010_P_1324(game):
    cid = 1324
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_R__1325(game):
    cid = 1325
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P__1326(game):
    cid = 1326
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_SEC_1327(game):
    cid = 1327
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P__1328(game):
    cid = 1328
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_R__1329(game):
    cid = 1329
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P_1330(game):
    cid = 1330
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_SEC_1331(game):
    cid = 1331
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_R__1332(game):
    cid = 1332
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P_1333(game):
    cid = 1333
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P__1334(game):
    cid = 1334
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_SEC_1335(game):
    cid = 1335
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_SEC_1336(game):
    cid = 1336
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_R__1337(game):
    cid = 1337
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P_1338(game):
    cid = 1338
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_010_P__1339(game):
    cid = 1339
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 8, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_011_P_1340(game):
    cid = 1340
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 30, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_011_R_1341(game):
    cid = 1341
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 30, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_011_R_1342(game):
    cid = 1342
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 30, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_011_P_1343(game):
    cid = 1343
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 30, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp2_012_N_1344(game):
    cid = 1344
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_013_N_1345(game):
    cid = 1345
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_014_N_1346(game):
    cid = 1346
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_015_N_1347(game):
    cid = 1347
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_016_N_1348(game):
    cid = 1348
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_017_N_1349(game):
    cid = 1349
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_018_N_1350(game):
    cid = 1350
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_019_N_1351(game):
    cid = 1351
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_020_N_1352(game):
    cid = 1352
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_021_N_1353(game):
    cid = 1353
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_022_N_1354(game):
    cid = 1354
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_001_P_1355(game):
    cid = 1355
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_001_R_1356(game):
    cid = 1356
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_001_R_1357(game):
    cid = 1357
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_001_P_1358(game):
    cid = 1358
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_002_P_1359(game):
    cid = 1359
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_002_R_1360(game):
    cid = 1360
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_002_R_1361(game):
    cid = 1361
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_002_P_1362(game):
    cid = 1362
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_003_P_1363(game):
    cid = 1363
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_003_R_1364(game):
    cid = 1364
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_003_R_1365(game):
    cid = 1365
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_003_P_1366(game):
    cid = 1366
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_004_P_1367(game):
    cid = 1367
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_R__1368(game):
    cid = 1368
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P__1369(game):
    cid = 1369
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_SEC_1370(game):
    cid = 1370
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P__1371(game):
    cid = 1371
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_R__1372(game):
    cid = 1372
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P_1373(game):
    cid = 1373
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_SEC_1374(game):
    cid = 1374
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_R__1375(game):
    cid = 1375
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P_1376(game):
    cid = 1376
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P__1377(game):
    cid = 1377
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_SEC_1378(game):
    cid = 1378
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_SEC_1379(game):
    cid = 1379
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_R__1380(game):
    cid = 1380
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P_1381(game):
    cid = 1381
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_004_P__1382(game):
    cid = 1382
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 22, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 39, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_bp4_005_P_1383(game):
    cid = 1383
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_R__1384(game):
    cid = 1384
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P__1385(game):
    cid = 1385
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_SEC_1386(game):
    cid = 1386
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P__1387(game):
    cid = 1387
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_R__1388(game):
    cid = 1388
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P_1389(game):
    cid = 1389
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_SEC_1390(game):
    cid = 1390
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_R__1391(game):
    cid = 1391
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P_1392(game):
    cid = 1392
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P__1393(game):
    cid = 1393
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_SEC_1394(game):
    cid = 1394
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_SEC_1395(game):
    cid = 1395
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_R__1396(game):
    cid = 1396
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P_1397(game):
    cid = 1397
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_005_P__1398(game):
    cid = 1398
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_006_P_1399(game):
    cid = 1399
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_006_R_1400(game):
    cid = 1400
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_006_R_1401(game):
    cid = 1401
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_006_P_1402(game):
    cid = 1402
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_007_P_1403(game):
    cid = 1403
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_007_R_1404(game):
    cid = 1404
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_007_R_1405(game):
    cid = 1405
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_007_P_1406(game):
    cid = 1406
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P_1407(game):
    cid = 1407
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_R__1408(game):
    cid = 1408
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P__1409(game):
    cid = 1409
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_SEC_1410(game):
    cid = 1410
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P__1411(game):
    cid = 1411
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_R__1412(game):
    cid = 1412
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P_1413(game):
    cid = 1413
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_SEC_1414(game):
    cid = 1414
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_R__1415(game):
    cid = 1415
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P_1416(game):
    cid = 1416
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P__1417(game):
    cid = 1417
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_SEC_1418(game):
    cid = 1418
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_SEC_1419(game):
    cid = 1419
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_R__1420(game):
    cid = 1420
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P_1421(game):
    cid = 1421
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_008_P__1422(game):
    cid = 1422
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 3, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 1, f"Trigger mismatch: {ab1.trigger} != 1"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 2
    ab2 = card.abilities[2]
    assert ab2.trigger == 2, f"Trigger mismatch: {ab2.trigger} != 2"
    assert len(ab2.conditions) == 0, "Condition count mismatch"
    assert len(ab2.effects) == 1, "Effect count mismatch"
    assert ab2.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab2.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_009_P_1423(game):
    cid = 1423
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_009_R_1424(game):
    cid = 1424
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_009_R_1425(game):
    cid = 1425
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_009_P_1426(game):
    cid = 1426
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_010_P_1427(game):
    cid = 1427
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_010_R_1428(game):
    cid = 1428
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_010_R_1429(game):
    cid = 1429
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_010_P_1430(game):
    cid = 1430
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P_1431(game):
    cid = 1431
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_R__1432(game):
    cid = 1432
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P__1433(game):
    cid = 1433
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_SEC_1434(game):
    cid = 1434
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P__1435(game):
    cid = 1435
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_R__1436(game):
    cid = 1436
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P_1437(game):
    cid = 1437
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_SEC_1438(game):
    cid = 1438
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_R__1439(game):
    cid = 1439
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P_1440(game):
    cid = 1440
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P__1441(game):
    cid = 1441
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_SEC_1442(game):
    cid = 1442
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_SEC_1443(game):
    cid = 1443
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_R__1444(game):
    cid = 1444
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P_1445(game):
    cid = 1445
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_011_P__1446(game):
    cid = 1446
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 19, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_012_N_1447(game):
    cid = 1447
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_013_N_1448(game):
    cid = 1448
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_014_N_1449(game):
    cid = 1449
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_015_N_1450(game):
    cid = 1450
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_016_N_1451(game):
    cid = 1451
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_017_N_1452(game):
    cid = 1452
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_018_N_1453(game):
    cid = 1453
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp4_019_N_1454(game):
    cid = 1454
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_020_N_1455(game):
    cid = 1455
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_021_N_1456(game):
    cid = 1456
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_022_N_1457(game):
    cid = 1457
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_001_P__1458(game):
    cid = 1458
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_001_R_1459(game):
    cid = 1459
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_001_R_1460(game):
    cid = 1460
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_001_P__1461(game):
    cid = 1461
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_002_P__1462(game):
    cid = 1462
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_002_R_1463(game):
    cid = 1463
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_002_R_1464(game):
    cid = 1464
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_002_P__1465(game):
    cid = 1465
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_003_P__1466(game):
    cid = 1466
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_003_R_1467(game):
    cid = 1467
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_003_R_1468(game):
    cid = 1468
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_003_P__1469(game):
    cid = 1469
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_004_P__1470(game):
    cid = 1470
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_004_R_1471(game):
    cid = 1471
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_004_R_1472(game):
    cid = 1472
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_004_P__1473(game):
    cid = 1473
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_005_P__1474(game):
    cid = 1474
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_005_R_1475(game):
    cid = 1475
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_005_R_1476(game):
    cid = 1476
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_005_P__1477(game):
    cid = 1477
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_006_P__1478(game):
    cid = 1478
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_006_R_1479(game):
    cid = 1479
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_006_R_1480(game):
    cid = 1480
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_006_P__1481(game):
    cid = 1481
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 10, f"Trigger mismatch: {ab1.trigger} != 10"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_007_P__1482(game):
    cid = 1482
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_007_R_1483(game):
    cid = 1483
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_007_R_1484(game):
    cid = 1484
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_007_P__1485(game):
    cid = 1485
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_008_P__1486(game):
    cid = 1486
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_008_R_1487(game):
    cid = 1487
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_008_R_1488(game):
    cid = 1488
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_008_P__1489(game):
    cid = 1489
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_009_P__1490(game):
    cid = 1490
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_009_R_1491(game):
    cid = 1491
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_009_R_1492(game):
    cid = 1492
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_009_P__1493(game):
    cid = 1493
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_010_P__1494(game):
    cid = 1494
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 4, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_010_R_1495(game):
    cid = 1495
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 4, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_010_R_1496(game):
    cid = 1496
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 4, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_010_P__1497(game):
    cid = 1497
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 4, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_011_P__1498(game):
    cid = 1498
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_011_R_1499(game):
    cid = 1499
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_011_R_1500(game):
    cid = 1500
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_011_P__1501(game):
    cid = 1501
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_012_N_1502(game):
    cid = 1502
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_013_N_1503(game):
    cid = 1503
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_014_N_1504(game):
    cid = 1504
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_015_N_1505(game):
    cid = 1505
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_016_N_1506(game):
    cid = 1506
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_017_N_1507(game):
    cid = 1507
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_pb1_018_N_1508(game):
    cid = 1508
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_019_N_1509(game):
    cid = 1509
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_020_N_1510(game):
    cid = 1510
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 10, f"Trigger mismatch: {ab0.trigger} != 10"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_021_N_1511(game):
    cid = 1511
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_022_N_1512(game):
    cid = 1512
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_001_SD_1513(game):
    cid = 1513
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_002_SD_1514(game):
    cid = 1514
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 39, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_003_SD_1515(game):
    cid = 1515
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_004_SD_1516(game):
    cid = 1516
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_005_SD_1517(game):
    cid = 1517
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_006_SD_1518(game):
    cid = 1518
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_007_SD_1519(game):
    cid = 1519
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_008_SD_1520(game):
    cid = 1520
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_sd1_009_SD_1521(game):
    cid = 1521
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_sd1_010_SD_1522(game):
    cid = 1522
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_011_SD_1523(game):
    cid = 1523
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 7, f"Trigger mismatch: {ab0.trigger} != 7"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_012_SD_1524(game):
    cid = 1524
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_013_SD_1525(game):
    cid = 1525
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_014_SD_1526(game):
    cid = 1526
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_015_SD_1527(game):
    cid = 1527
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_016_SD_1528(game):
    cid = 1528
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_sd1_017_SD_1529(game):
    cid = 1529
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 1, f"Trigger mismatch: {ab0.trigger} != 1"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 41, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_SP_sd1_018_SD_1530(game):
    cid = 1530
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_019_SD_1531(game):
    cid = 1531
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_020_SD_1532(game):
    cid = 1532
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_021_SD_1533(game):
    cid = 1533
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_022_SD_1534(game):
    cid = 1534
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_004_PR_30000(game):
    cid = 30000
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_019_L_30001(game):
    cid = 30001
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_020_L_30002(game):
    cid = 30002
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_020_L__30003(game):
    cid = 30003
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_020_L__30004(game):
    cid = 30004
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_020_L_30005(game):
    cid = 30005
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_021_L_30006(game):
    cid = 30006
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_022_L_30007(game):
    cid = 30007
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 27, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp3_023_L_30008(game):
    cid = 30008
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL__bp3_024_L_30009(game):
    cid = 30009
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 4, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 37, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 2, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 6, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"


def test_strict_PL__bp3_025_L_30010(game):
    cid = 30010
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp3_026_L_30011(game):
    cid = 30011
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_019_L_30012(game):
    cid = 30012
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL__bp4_020_L_30013(game):
    cid = 30013
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 10, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 7, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_021_L_30014(game):
    cid = 30014
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__bp4_022_L_30015(game):
    cid = 30015
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL__bp4_023_L_30016(game):
    cid = 30016
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_024_L_30017(game):
    cid = 30017
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__bp4_025_L_30018(game):
    cid = 30018
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_026_L_30019(game):
    cid = 30019
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_028_L_30020(game):
    cid = 30020
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL__pb1_029_L_30021(game):
    cid = 30021
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_030_L_30022(game):
    cid = 30022
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 9, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_031_L_30023(game):
    cid = 30023
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_032_L_30024(game):
    cid = 30024
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL__pb1_033_L_30025(game):
    cid = 30025
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_019_SD_30026(game):
    cid = 30026
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 11, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL__sd1_020_SD_30027(game):
    cid = 30027
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_021_SD_30028(game):
    cid = 30028
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_022_SD_30029(game):
    cid = 30029
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_PR_010_PR_30030(game):
    cid = 30030
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_PR_011_PR_30031(game):
    cid = 30031
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_PR_012_PR_30032(game):
    cid = 30032
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_bp1_019_L_30033(game):
    cid = 30033
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_bp1_020_L_30034(game):
    cid = 30034
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_bp1_021_L_30035(game):
    cid = 30035
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 5, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_022_L_30036(game):
    cid = 30036
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp1_023_L_30037(game):
    cid = 30037
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_019_L_30038(game):
    cid = 30038
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_HS_bp2_020_L_30039(game):
    cid = 30039
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_021_L_30040(game):
    cid = 30040
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_022_L_30041(game):
    cid = 30041
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_023_L_30042(game):
    cid = 30042
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_024_L_30043(game):
    cid = 30043
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 2, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_025_L_30044(game):
    cid = 30044
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_HS_bp2_026_L_30045(game):
    cid = 30045
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 3, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert ab0.conditions[2].type == 0, "Condition 2 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_025_L_30046(game):
    cid = 30046
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_N_bp1_026_L_30047(game):
    cid = 30047
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_027_L_30048(game):
    cid = 30048
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_028_L_30049(game):
    cid = 30049
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp1_029_L_30050(game):
    cid = 30050
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_025_L_30051(game):
    cid = 30051
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_026_L_30052(game):
    cid = 30052
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp3_027_L_30053(game):
    cid = 30053
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_028_L_30054(game):
    cid = 30054
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 33, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 26, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 6, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_N_bp3_029_L_30055(game):
    cid = 30055
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_030_L_30056(game):
    cid = 30056
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_031_L_30057(game):
    cid = 30057
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp3_032_L_30058(game):
    cid = 30058
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_025_L_30059(game):
    cid = 30059
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_026_L_30060(game):
    cid = 30060
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 0, f"Trigger mismatch: {ab1.trigger} != 0"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_N_bp4_027_L_30061(game):
    cid = 30061
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_028_L_30062(game):
    cid = 30062
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 6, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_029_L_30063(game):
    cid = 30063
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_030_L_30064(game):
    cid = 30064
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 17, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 99, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_031_L_30065(game):
    cid = 30065
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 4, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 18, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 3, "Effect 1 value mismatch"


def test_strict_PL_N_bp4_032_L_30066(game):
    cid = 30066
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_032_L__30067(game):
    cid = 30067
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_032_L__30068(game):
    cid = 30068
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_032_L_30069(game):
    cid = 30069
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_037_L_30070(game):
    cid = 30070
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 6, f"Trigger mismatch: {ab1.trigger} != 6"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 29, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_N_pb1_038_L_30071(game):
    cid = 30071
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_039_L_30072(game):
    cid = 30072
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 15, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 2, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 5, "Effect 0 value mismatch"


def test_strict_PL_N_pb1_040_L_30073(game):
    cid = 30073
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_041_L_30074(game):
    cid = 30074
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_041_L__30075(game):
    cid = 30075
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_041_L__30076(game):
    cid = 30076
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_041_L_30077(game):
    cid = 30077
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_042_L_30078(game):
    cid = 30078
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 9, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 4, "Condition 1 type mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_N_sd1_025_SD_30079(game):
    cid = 30079
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_N_sd1_026_SD_30080(game):
    cid = 30080
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_N_sd1_027_SD_30081(game):
    cid = 30081
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_N_sd1_028_SD_30082(game):
    cid = 30082
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_PR_022_PR_30083(game):
    cid = 30083
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_023_PR_30084(game):
    cid = 30084
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_024_PR_30085(game):
    cid = 30085
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_019_L_30086(game):
    cid = 30086
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_020_L_30087(game):
    cid = 30087
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_021_L_30088(game):
    cid = 30088
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 18, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_022_L_30089(game):
    cid = 30089
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_023_L_30090(game):
    cid = 30090
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp2_024_L_30091(game):
    cid = 30091
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 2, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab1.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab1.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_025_L_30092(game):
    cid = 30092
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_S_bp2_026_L_30093(game):
    cid = 30093
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_019_L_30094(game):
    cid = 30094
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 23, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 4, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_020_L_30095(game):
    cid = 30095
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 0, f"Trigger mismatch: {ab0.trigger} != 0"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 1, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 41, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 99, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_S_bp3_021_L_30096(game):
    cid = 30096
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 1, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_bp3_022_L_30097(game):
    cid = 30097
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_023_L_30098(game):
    cid = 30098
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_024_L_30099(game):
    cid = 30099
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 2, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 17, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_bp3_025_L_30100(game):
    cid = 30100
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 25, "Condition 0 type mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 6, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"


def test_strict_PL_S_pb1_019_L_30101(game):
    cid = 30101
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 14, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 0, "Condition count mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_020_L_30102(game):
    cid = 30102
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_021_L_30103(game):
    cid = 30103
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 2, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab0.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_022_L_30104(game):
    cid = 30104
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_022_L__30105(game):
    cid = 30105
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_022_L__30106(game):
    cid = 30106
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_022_L_30107(game):
    cid = 30107
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_S_pb1_023_L_30108(game):
    cid = 30108
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_023_L__30109(game):
    cid = 30109
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_023_L__30110(game):
    cid = 30110
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_023_L_30111(game):
    cid = 30111
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_024_L_30112(game):
    cid = 30112
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 2, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 2, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"


def test_strict_PL_SP_bp1_023_L_30113(game):
    cid = 30113
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 13, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_024_L_30114(game):
    cid = 30114
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 6, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 0, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"
    assert ab0.effects[4].effect_type == 0, "Effect 4 type mismatch"
    assert ab0.effects[4].value == 1, "Effect 4 value mismatch"
    assert ab0.effects[5].effect_type == 1, "Effect 5 type mismatch"
    assert ab0.effects[5].value == 1, "Effect 5 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 2, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 2, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_025_L_30115(game):
    cid = 30115
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_025_L__30116(game):
    cid = 30116
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_bp1_025_L__30117(game):
    cid = 30117
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_025_L_30118(game):
    cid = 30118
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_026_L_30119(game):
    cid = 30119
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp1_027_L_30120(game):
    cid = 30120
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_023_L_30121(game):
    cid = 30121
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 19, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_024_L_30122(game):
    cid = 30122
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_025_L_30123(game):
    cid = 30123
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 7, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp2_026_L_30124(game):
    cid = 30124
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_027_L_30125(game):
    cid = 30125
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_023_L_30126(game):
    cid = 30126
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 5, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 1, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 1, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"
    assert ab0.effects[3].effect_type == 1, "Effect 3 type mismatch"
    assert ab0.effects[3].value == 1, "Effect 3 value mismatch"
    assert ab0.effects[4].effect_type == 0, "Effect 4 type mismatch"
    assert ab0.effects[4].value == 99, "Effect 4 value mismatch"


def test_strict_PL_SP_bp4_024_L_30127(game):
    cid = 30127
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 21, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 2, f"Trigger mismatch: {ab1.trigger} != 2"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 24, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 1, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 2, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_025_L_30128(game):
    cid = 30128
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 3, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 2, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert ab1.conditions[1].type == 0, "Condition 1 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_026_L_30129(game):
    cid = 30129
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 3, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"
    assert ab0.effects[1].effect_type == 0, "Effect 1 type mismatch"
    assert ab0.effects[1].value == 2, "Effect 1 value mismatch"
    assert ab0.effects[2].effect_type == 0, "Effect 2 type mismatch"
    assert ab0.effects[2].value == 1, "Effect 2 value mismatch"


def test_strict_PL_SP_bp4_027_L_30130(game):
    cid = 30130
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 3, f"Trigger mismatch: {ab0.trigger} != 3"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 33, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_028_L_30131(game):
    cid = 30131
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_bp4_029_L_30132(game):
    cid = 30132
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_030_L_30133(game):
    cid = 30133
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_023_L_30134(game):
    cid = 30134
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 2, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 0, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 6, "Effect 0 value mismatch"

    # Ability 1
    ab1 = card.abilities[1]
    assert ab1.trigger == 3, f"Trigger mismatch: {ab1.trigger} != 3"
    assert len(ab1.conditions) == 1, "Condition count mismatch"
    assert ab1.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab1.effects) == 1, "Effect count mismatch"
    assert ab1.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab1.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_024_L_30135(game):
    cid = 30135
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_PL_SP_pb1_025_L_30136(game):
    cid = 30136
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_pb1_026_L_30137(game):
    cid = 30137
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_026_L__30138(game):
    cid = 30138
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_026_L__30139(game):
    cid = 30139
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_026_L_30140(game):
    cid = 30140
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_023_SD_30141(game):
    cid = 30141
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_sd1_024_SD_30142(game):
    cid = 30142
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_sd1_025_SD_30143(game):
    cid = 30143
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 6, f"Trigger mismatch: {ab0.trigger} != 6"
    assert len(ab0.conditions) == 0, "Condition count mismatch"
    assert len(ab0.effects) == 0, "Effect count mismatch"


def test_strict_PL_SP_sd1_026_SD_30144(game):
    cid = 30144
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 1, "Ability count mismatch"

    # Ability 0
    ab0 = card.abilities[0]
    assert ab0.trigger == 2, f"Trigger mismatch: {ab0.trigger} != 2"
    assert len(ab0.conditions) == 1, "Condition count mismatch"
    assert ab0.conditions[0].type == 0, "Condition 0 type mismatch"
    assert len(ab0.effects) == 1, "Effect count mismatch"
    assert ab0.effects[0].effect_type == 6, "Effect 0 type mismatch"
    assert ab0.effects[0].value == 1, "Effect 0 value mismatch"


def test_strict_LL_E_001_SD_40000(game):
    cid = 40000
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_E_002_PR_40001(game):
    cid = 40001
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_E_003_SD_40002(game):
    cid = 40002
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_E_004_PR_40003(game):
    cid = 40003
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_E_005_SD_40004(game):
    cid = 40004
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_001_PR_40005(game):
    cid = 40005
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_002_PR_40006(game):
    cid = 40006
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_003_PR_40007(game):
    cid = 40007
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_006_PR_40008(game):
    cid = 40008
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_LL_PR_007_PR_40009(game):
    cid = 40009
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__PR_010_PR__40010(game):
    cid = 40010
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__PR_011_PR__40011(game):
    cid = 40011
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp1_000_LLE_40012(game):
    cid = 40012
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_027_SECE_40013(game):
    cid = 40013
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_028_SECE_40014(game):
    cid = 40014
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_029_SECE_40015(game):
    cid = 40015
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_030_PE_40016(game):
    cid = 40016
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_030_PE__40017(game):
    cid = 40017
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_030_PE__40018(game):
    cid = 40018
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_030_PE_40019(game):
    cid = 40019
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_031_PE_40020(game):
    cid = 40020
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_031_PE__40021(game):
    cid = 40021
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_031_PE__40022(game):
    cid = 40022
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_031_PE_40023(game):
    cid = 40023
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_032_PE_40024(game):
    cid = 40024
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_032_PE__40025(game):
    cid = 40025
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_032_PE__40026(game):
    cid = 40026
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_032_PE_40027(game):
    cid = 40027
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_100_LLE_40028(game):
    cid = 40028
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp3_200_LLE_40029(game):
    cid = 40029
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_027_SECE_40030(game):
    cid = 40030
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_028_SECE_40031(game):
    cid = 40031
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_029_PE_40032(game):
    cid = 40032
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_029_PE__40033(game):
    cid = 40033
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_029_PE__40034(game):
    cid = 40034
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_029_PE_40035(game):
    cid = 40035
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_030_PE_40036(game):
    cid = 40036
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_030_PE__40037(game):
    cid = 40037
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_030_PE__40038(game):
    cid = 40038
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_030_PE_40039(game):
    cid = 40039
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_031_PE_40040(game):
    cid = 40040
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_031_PE__40041(game):
    cid = 40041
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_031_PE__40042(game):
    cid = 40042
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_031_PE_40043(game):
    cid = 40043
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_100_LLE_40044(game):
    cid = 40044
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__bp4_200_LLE_40045(game):
    cid = 40045
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_034_PE_40046(game):
    cid = 40046
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_034_PE__40047(game):
    cid = 40047
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_034_PE__40048(game):
    cid = 40048
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_034_PE_40049(game):
    cid = 40049
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_035_PE_40050(game):
    cid = 40050
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_035_PE__40051(game):
    cid = 40051
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_035_PE__40052(game):
    cid = 40052
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_035_PE_40053(game):
    cid = 40053
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_036_PE_40054(game):
    cid = 40054
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_036_PE__40055(game):
    cid = 40055
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_036_PE__40056(game):
    cid = 40056
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_036_PE_40057(game):
    cid = 40057
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_037_PE_40058(game):
    cid = 40058
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_037_PE__40059(game):
    cid = 40059
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_037_PE__40060(game):
    cid = 40060
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_037_PE_40061(game):
    cid = 40061
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_038_PE_40062(game):
    cid = 40062
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_038_PE__40063(game):
    cid = 40063
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_038_PE__40064(game):
    cid = 40064
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_038_PE_40065(game):
    cid = 40065
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_039_PE_40066(game):
    cid = 40066
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_039_PE__40067(game):
    cid = 40067
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_039_PE__40068(game):
    cid = 40068
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_039_PE_40069(game):
    cid = 40069
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_040_PE_40070(game):
    cid = 40070
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_040_PE__40071(game):
    cid = 40071
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_040_PE__40072(game):
    cid = 40072
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_040_PE_40073(game):
    cid = 40073
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_041_PE_40074(game):
    cid = 40074
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_041_PE__40075(game):
    cid = 40075
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_041_PE__40076(game):
    cid = 40076
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_041_PE_40077(game):
    cid = 40077
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_042_PE_40078(game):
    cid = 40078
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_042_PE__40079(game):
    cid = 40079
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_042_PE__40080(game):
    cid = 40080
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_042_PE_40081(game):
    cid = 40081
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_043_SRE_40082(game):
    cid = 40082
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_044_SRE_40083(game):
    cid = 40083
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_045_SRE_40084(game):
    cid = 40084
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_046_SRE_40085(game):
    cid = 40085
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_047_SRE_40086(game):
    cid = 40086
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_048_SRE_40087(game):
    cid = 40087
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_049_SRE_40088(game):
    cid = 40088
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_050_SRE_40089(game):
    cid = 40089
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_051_SRE_40090(game):
    cid = 40090
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_052_SECE_40091(game):
    cid = 40091
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_052_SRE_40092(game):
    cid = 40092
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_052_SRE_40093(game):
    cid = 40093
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_052_SECE_40094(game):
    cid = 40094
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_053_SRE_40095(game):
    cid = 40095
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_054_SRE_40096(game):
    cid = 40096
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_055_SRE_40097(game):
    cid = 40097
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_056_SRE_40098(game):
    cid = 40098
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_057_SRE_40099(game):
    cid = 40099
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_058_SRE_40100(game):
    cid = 40100
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_059_SRE_40101(game):
    cid = 40101
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_060_SRE_40102(game):
    cid = 40102
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_061_SRE_40103(game):
    cid = 40103
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_100_LLE_40104(game):
    cid = 40104
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_200_LLE_40105(game):
    cid = 40105
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_300_LLE_40106(game):
    cid = 40106
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_400_LLE_40107(game):
    cid = 40107
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_500_LLE_40108(game):
    cid = 40108
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__pb1_600_LLE_40109(game):
    cid = 40109
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_023_P_40110(game):
    cid = 40110
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_024_P_40111(game):
    cid = 40111
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_025_P_40112(game):
    cid = 40112
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_026_P_40113(game):
    cid = 40113
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_027_P_40114(game):
    cid = 40114
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_028_P_40115(game):
    cid = 40115
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_029_P_40116(game):
    cid = 40116
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_030_P_40117(game):
    cid = 40117
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL__sd1_031_P_40118(game):
    cid = 40118
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_013_PR_40119(game):
    cid = 40119
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_015_PR_40120(game):
    cid = 40120
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_024_PR__40121(game):
    cid = 40121
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_PR_025_PR__40122(game):
    cid = 40122
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_000_LLE_40123(game):
    cid = 40123
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_024_SECE_40124(game):
    cid = 40124
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_025_SECE_40125(game):
    cid = 40125
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_026_SECE_40126(game):
    cid = 40126
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_027_PE_40127(game):
    cid = 40127
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_027_PE__40128(game):
    cid = 40128
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_027_PE__40129(game):
    cid = 40129
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_027_PE_40130(game):
    cid = 40130
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_028_PE_40131(game):
    cid = 40131
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_028_PE__40132(game):
    cid = 40132
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_028_PE__40133(game):
    cid = 40133
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_028_PE_40134(game):
    cid = 40134
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_029_PE_40135(game):
    cid = 40135
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_029_PE__40136(game):
    cid = 40136
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_029_PE__40137(game):
    cid = 40137
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_029_PE_40138(game):
    cid = 40138
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_030_PE_40139(game):
    cid = 40139
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_030_PE__40140(game):
    cid = 40140
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_030_PE__40141(game):
    cid = 40141
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_030_PE_40142(game):
    cid = 40142
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_031_PE_40143(game):
    cid = 40143
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_031_PE__40144(game):
    cid = 40144
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_031_PE__40145(game):
    cid = 40145
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_031_PE_40146(game):
    cid = 40146
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp1_999_SEC__40147(game):
    cid = 40147
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_027_SECE_40148(game):
    cid = 40148
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_028_SECE_40149(game):
    cid = 40149
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_029_SECE_40150(game):
    cid = 40150
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_030_PE_40151(game):
    cid = 40151
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_030_PE__40152(game):
    cid = 40152
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_030_PE__40153(game):
    cid = 40153
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_030_PE_40154(game):
    cid = 40154
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_031_PE_40155(game):
    cid = 40155
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_031_PE__40156(game):
    cid = 40156
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_031_PE__40157(game):
    cid = 40157
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_031_PE_40158(game):
    cid = 40158
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_032_PE_40159(game):
    cid = 40159
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_032_PE__40160(game):
    cid = 40160
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_032_PE__40161(game):
    cid = 40161
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_032_PE_40162(game):
    cid = 40162
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_033_PE_40163(game):
    cid = 40163
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_033_PE__40164(game):
    cid = 40164
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_033_PE__40165(game):
    cid = 40165
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_033_PE_40166(game):
    cid = 40166
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_100_LLE_40167(game):
    cid = 40167
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_200_LLE_40168(game):
    cid = 40168
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_HS_bp2_999_SEC__40169(game):
    cid = 40169
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_PR_001_PR_40170(game):
    cid = 40170
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_PR_002_PR_40171(game):
    cid = 40171
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_PR_015_PR__40172(game):
    cid = 40172
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_PR_016_PR_40173(game):
    cid = 40173
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_PR_017_PR__40174(game):
    cid = 40174
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_000_LLE_40175(game):
    cid = 40175
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_030_SECE_40176(game):
    cid = 40176
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_031_SECE_40177(game):
    cid = 40177
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_032_SECE_40178(game):
    cid = 40178
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_033_SECE_40179(game):
    cid = 40179
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_034_PE_40180(game):
    cid = 40180
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_034_PE__40181(game):
    cid = 40181
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_034_PE__40182(game):
    cid = 40182
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_034_PE_40183(game):
    cid = 40183
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_035_PE_40184(game):
    cid = 40184
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_035_PE__40185(game):
    cid = 40185
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_035_PE__40186(game):
    cid = 40186
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_035_PE_40187(game):
    cid = 40187
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_036_PE_40188(game):
    cid = 40188
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_036_PE__40189(game):
    cid = 40189
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_036_PE__40190(game):
    cid = 40190
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_036_PE_40191(game):
    cid = 40191
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_037_PE_40192(game):
    cid = 40192
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_037_PE__40193(game):
    cid = 40193
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_037_PE__40194(game):
    cid = 40194
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_037_PE_40195(game):
    cid = 40195
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_038_PE_40196(game):
    cid = 40196
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_038_PE__40197(game):
    cid = 40197
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_038_PE__40198(game):
    cid = 40198
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_038_PE_40199(game):
    cid = 40199
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp1_999_SEC__40200(game):
    cid = 40200
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_033_SECE_40201(game):
    cid = 40201
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_034_SECE_40202(game):
    cid = 40202
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_035_SECE_40203(game):
    cid = 40203
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_036_SECE_40204(game):
    cid = 40204
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_037_PE_40205(game):
    cid = 40205
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_037_PE__40206(game):
    cid = 40206
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_037_PE__40207(game):
    cid = 40207
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_037_PE_40208(game):
    cid = 40208
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_038_PE_40209(game):
    cid = 40209
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_038_PE__40210(game):
    cid = 40210
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_038_PE__40211(game):
    cid = 40211
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_038_PE_40212(game):
    cid = 40212
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_039_PE_40213(game):
    cid = 40213
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_039_PE__40214(game):
    cid = 40214
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_039_PE__40215(game):
    cid = 40215
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_039_PE_40216(game):
    cid = 40216
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_040_PE__40217(game):
    cid = 40217
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_100_LLE_40218(game):
    cid = 40218
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp3_200_LLE_40219(game):
    cid = 40219
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_033_SECE_40220(game):
    cid = 40220
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_034_SECE_40221(game):
    cid = 40221
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_035_SECE_40222(game):
    cid = 40222
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_036_SECE_40223(game):
    cid = 40223
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_037_SECE_40224(game):
    cid = 40224
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_038_PE_40225(game):
    cid = 40225
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_038_PE__40226(game):
    cid = 40226
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_038_PE__40227(game):
    cid = 40227
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_038_PE_40228(game):
    cid = 40228
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_039_PE_40229(game):
    cid = 40229
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_039_PE__40230(game):
    cid = 40230
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_039_PE__40231(game):
    cid = 40231
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_039_PE_40232(game):
    cid = 40232
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_040_PE_40233(game):
    cid = 40233
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_040_PE__40234(game):
    cid = 40234
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_040_PE__40235(game):
    cid = 40235
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_040_PE_40236(game):
    cid = 40236
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_041_PE_40237(game):
    cid = 40237
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_041_PE__40238(game):
    cid = 40238
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_041_PE__40239(game):
    cid = 40239
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_041_PE_40240(game):
    cid = 40240
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_100_LLE_40241(game):
    cid = 40241
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_bp4_200_LLE_40242(game):
    cid = 40242
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_043_PE_40243(game):
    cid = 40243
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_043_PE__40244(game):
    cid = 40244
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_043_PE__40245(game):
    cid = 40245
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_043_PE_40246(game):
    cid = 40246
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_044_PE_40247(game):
    cid = 40247
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_044_PE__40248(game):
    cid = 40248
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_044_PE__40249(game):
    cid = 40249
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_044_PE_40250(game):
    cid = 40250
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_045_PE_40251(game):
    cid = 40251
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_045_PE__40252(game):
    cid = 40252
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_045_PE__40253(game):
    cid = 40253
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_045_PE_40254(game):
    cid = 40254
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_046_PE_40255(game):
    cid = 40255
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_046_PE__40256(game):
    cid = 40256
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_046_PE__40257(game):
    cid = 40257
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_046_PE_40258(game):
    cid = 40258
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_047_PE_40259(game):
    cid = 40259
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_047_PE__40260(game):
    cid = 40260
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_047_PE__40261(game):
    cid = 40261
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_047_PE_40262(game):
    cid = 40262
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_048_PE_40263(game):
    cid = 40263
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_048_PE__40264(game):
    cid = 40264
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_048_PE__40265(game):
    cid = 40265
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_048_PE_40266(game):
    cid = 40266
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_049_PE_40267(game):
    cid = 40267
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_049_PE__40268(game):
    cid = 40268
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_049_PE__40269(game):
    cid = 40269
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_049_PE_40270(game):
    cid = 40270
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_050_PE_40271(game):
    cid = 40271
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_050_PE__40272(game):
    cid = 40272
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_050_PE__40273(game):
    cid = 40273
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_050_PE_40274(game):
    cid = 40274
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_051_PE_40275(game):
    cid = 40275
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_051_PE__40276(game):
    cid = 40276
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_051_PE__40277(game):
    cid = 40277
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_051_PE_40278(game):
    cid = 40278
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_052_PE_40279(game):
    cid = 40279
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_052_PE__40280(game):
    cid = 40280
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_052_PE__40281(game):
    cid = 40281
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_052_PE_40282(game):
    cid = 40282
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_053_PE_40283(game):
    cid = 40283
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_053_PE__40284(game):
    cid = 40284
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_053_PE__40285(game):
    cid = 40285
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_053_PE_40286(game):
    cid = 40286
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_054_PE_40287(game):
    cid = 40287
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_054_PE__40288(game):
    cid = 40288
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_054_PE__40289(game):
    cid = 40289
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_054_PE_40290(game):
    cid = 40290
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_055_PE__40291(game):
    cid = 40291
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_056_SRE_40292(game):
    cid = 40292
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_057_SRE_40293(game):
    cid = 40293
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_058_SRE_40294(game):
    cid = 40294
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_059_SRE_40295(game):
    cid = 40295
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_060_SRE_40296(game):
    cid = 40296
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_061_SRE_40297(game):
    cid = 40297
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_062_SRE_40298(game):
    cid = 40298
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_063_SRE_40299(game):
    cid = 40299
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_064_SRE_40300(game):
    cid = 40300
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_065_SRE_40301(game):
    cid = 40301
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_066_SRE_40302(game):
    cid = 40302
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_067_SRE_40303(game):
    cid = 40303
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_068_SRE_40304(game):
    cid = 40304
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_069_SRE_40305(game):
    cid = 40305
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_070_SRE_40306(game):
    cid = 40306
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_071_SRE_40307(game):
    cid = 40307
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_072_SRE_40308(game):
    cid = 40308
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_073_SRE_40309(game):
    cid = 40309
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_074_SRE_40310(game):
    cid = 40310
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_075_SRE_40311(game):
    cid = 40311
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_076_SRE_40312(game):
    cid = 40312
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_077_SRE_40313(game):
    cid = 40313
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_078_SRE_40314(game):
    cid = 40314
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_079_SRE_40315(game):
    cid = 40315
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_080_SRE_40316(game):
    cid = 40316
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_081_SRE_40317(game):
    cid = 40317
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_082_SRE_40318(game):
    cid = 40318
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_083_SECE_40319(game):
    cid = 40319
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_083_SRE_40320(game):
    cid = 40320
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_083_SRE_40321(game):
    cid = 40321
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_083_SECE_40322(game):
    cid = 40322
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_100_LLE_40323(game):
    cid = 40323
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_200_LLE_40324(game):
    cid = 40324
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_300_LLE_40325(game):
    cid = 40325
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_400_LLE_40326(game):
    cid = 40326
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_500_LLE_40327(game):
    cid = 40327
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_600_LLE_40328(game):
    cid = 40328
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_700_LLE_40329(game):
    cid = 40329
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_pb1_800_LLE_40330(game):
    cid = 40330
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_029_P_40331(game):
    cid = 40331
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_030_P_40332(game):
    cid = 40332
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_031_P_40333(game):
    cid = 40333
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_032_P_40334(game):
    cid = 40334
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_033_P_40335(game):
    cid = 40335
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_034_P_40336(game):
    cid = 40336
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_035_P_40337(game):
    cid = 40337
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_036_P_40338(game):
    cid = 40338
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_037_P_40339(game):
    cid = 40339
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_038_P_40340(game):
    cid = 40340
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_039_P_40341(game):
    cid = 40341
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_N_sd1_040_P_40342(game):
    cid = 40342
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_001_PR_40343(game):
    cid = 40343
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_002_PR_40344(game):
    cid = 40344
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_003_PR_40345(game):
    cid = 40345
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_004_PR_40346(game):
    cid = 40346
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_005_PR_40347(game):
    cid = 40347
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_006_PR_40348(game):
    cid = 40348
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_007_PR_40349(game):
    cid = 40349
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_008_PR_40350(game):
    cid = 40350
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_009_PR_40351(game):
    cid = 40351
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_010_PR_40352(game):
    cid = 40352
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_011_PR__40353(game):
    cid = 40353
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_012_PR__40354(game):
    cid = 40354
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_034_PR2_40355(game):
    cid = 40355
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_035_PR_40356(game):
    cid = 40356
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_PR_036_PR__40357(game):
    cid = 40357
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp1_000_LLE_40358(game):
    cid = 40358
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_027_SECE_40359(game):
    cid = 40359
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_028_SECE_40360(game):
    cid = 40360
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_029_SECE_40361(game):
    cid = 40361
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_030_PE_40362(game):
    cid = 40362
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_030_PE__40363(game):
    cid = 40363
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_030_PE__40364(game):
    cid = 40364
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_030_PE_40365(game):
    cid = 40365
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_031_PE_40366(game):
    cid = 40366
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_031_PE__40367(game):
    cid = 40367
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_031_PE__40368(game):
    cid = 40368
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_031_PE_40369(game):
    cid = 40369
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_032_PE_40370(game):
    cid = 40370
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_032_PE__40371(game):
    cid = 40371
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_032_PE__40372(game):
    cid = 40372
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_032_PE_40373(game):
    cid = 40373
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_033_PE_40374(game):
    cid = 40374
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_033_PE__40375(game):
    cid = 40375
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_033_PE__40376(game):
    cid = 40376
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_033_PE_40377(game):
    cid = 40377
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_100_LLE_40378(game):
    cid = 40378
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_200_LLE_40379(game):
    cid = 40379
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp2_999_SEC__40380(game):
    cid = 40380
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_026_SECE_40381(game):
    cid = 40381
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_027_SECE_40382(game):
    cid = 40382
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_028_SECE_40383(game):
    cid = 40383
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_029_PE_40384(game):
    cid = 40384
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_029_PE__40385(game):
    cid = 40385
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_029_PE__40386(game):
    cid = 40386
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_029_PE_40387(game):
    cid = 40387
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_030_PE_40388(game):
    cid = 40388
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_030_PE__40389(game):
    cid = 40389
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_030_PE__40390(game):
    cid = 40390
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_030_PE_40391(game):
    cid = 40391
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_031_PE_40392(game):
    cid = 40392
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_031_PE__40393(game):
    cid = 40393
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_031_PE__40394(game):
    cid = 40394
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_031_PE_40395(game):
    cid = 40395
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_100_LLE_40396(game):
    cid = 40396
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_bp3_200_LLE_40397(game):
    cid = 40397
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_025_PE_40398(game):
    cid = 40398
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_025_PE__40399(game):
    cid = 40399
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_025_PE__40400(game):
    cid = 40400
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_025_PE_40401(game):
    cid = 40401
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_026_PE_40402(game):
    cid = 40402
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_026_PE__40403(game):
    cid = 40403
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_026_PE__40404(game):
    cid = 40404
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_026_PE_40405(game):
    cid = 40405
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_027_PE_40406(game):
    cid = 40406
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_027_PE__40407(game):
    cid = 40407
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_027_PE__40408(game):
    cid = 40408
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_027_PE_40409(game):
    cid = 40409
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_028_PE_40410(game):
    cid = 40410
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_028_PE__40411(game):
    cid = 40411
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_028_PE__40412(game):
    cid = 40412
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_028_PE_40413(game):
    cid = 40413
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_029_PE_40414(game):
    cid = 40414
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_029_PE__40415(game):
    cid = 40415
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_029_PE__40416(game):
    cid = 40416
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_029_PE_40417(game):
    cid = 40417
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_030_PE_40418(game):
    cid = 40418
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_030_PE__40419(game):
    cid = 40419
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_030_PE__40420(game):
    cid = 40420
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_030_PE_40421(game):
    cid = 40421
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_031_PE_40422(game):
    cid = 40422
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_031_PE__40423(game):
    cid = 40423
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_031_PE__40424(game):
    cid = 40424
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_031_PE_40425(game):
    cid = 40425
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_032_PE_40426(game):
    cid = 40426
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_032_PE__40427(game):
    cid = 40427
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_032_PE__40428(game):
    cid = 40428
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_032_PE_40429(game):
    cid = 40429
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_033_PE_40430(game):
    cid = 40430
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_033_PE__40431(game):
    cid = 40431
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_033_PE__40432(game):
    cid = 40432
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_033_PE_40433(game):
    cid = 40433
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_034_SRE_40434(game):
    cid = 40434
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_035_SRE_40435(game):
    cid = 40435
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_036_SRE_40436(game):
    cid = 40436
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_037_SRE_40437(game):
    cid = 40437
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_038_SRE_40438(game):
    cid = 40438
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_039_SRE_40439(game):
    cid = 40439
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_040_SRE_40440(game):
    cid = 40440
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_041_SRE_40441(game):
    cid = 40441
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_042_SRE_40442(game):
    cid = 40442
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_043_SRE_40443(game):
    cid = 40443
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_044_SRE_40444(game):
    cid = 40444
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_045_SRE_40445(game):
    cid = 40445
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_046_SRE_40446(game):
    cid = 40446
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_047_SRE_40447(game):
    cid = 40447
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_048_SRE_40448(game):
    cid = 40448
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_049_SRE_40449(game):
    cid = 40449
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_050_SRE_40450(game):
    cid = 40450
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_051_SRE_40451(game):
    cid = 40451
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_052_SECE_40452(game):
    cid = 40452
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_052_SRE_40453(game):
    cid = 40453
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_052_SRE_40454(game):
    cid = 40454
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_052_SECE_40455(game):
    cid = 40455
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_053_SECE_40456(game):
    cid = 40456
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_054_SRE_40457(game):
    cid = 40457
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_055_SRE_40458(game):
    cid = 40458
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_056_SRE_40459(game):
    cid = 40459
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_057_SRE_40460(game):
    cid = 40460
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_058_SRE_40461(game):
    cid = 40461
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_059_SRE_40462(game):
    cid = 40462
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_060_SRE_40463(game):
    cid = 40463
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_061_SRE_40464(game):
    cid = 40464
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_062_SRE_40465(game):
    cid = 40465
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_063_SRE_40466(game):
    cid = 40466
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_064_LLE_40467(game):
    cid = 40467
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_065_LLE_40468(game):
    cid = 40468
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_066_LLE_40469(game):
    cid = 40469
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_067_LLE_40470(game):
    cid = 40470
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_068_LLE_40471(game):
    cid = 40471
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_069_LLE_40472(game):
    cid = 40472
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_070_LLE_40473(game):
    cid = 40473
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_071_LLE_40474(game):
    cid = 40474
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_S_pb1_072_LLE_40475(game):
    cid = 40475
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_001_PR_40476(game):
    cid = 40476
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_002_PR_40477(game):
    cid = 40477
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_014_PR__40478(game):
    cid = 40478
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_PR_015_PR__40479(game):
    cid = 40479
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_000_LLE_40480(game):
    cid = 40480
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_028_SECE_40481(game):
    cid = 40481
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_029_SECE_40482(game):
    cid = 40482
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_030_SECE_40483(game):
    cid = 40483
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_031_PE_40484(game):
    cid = 40484
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_031_PE__40485(game):
    cid = 40485
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_031_PE__40486(game):
    cid = 40486
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_031_PE_40487(game):
    cid = 40487
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_032_PE_40488(game):
    cid = 40488
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_032_PE__40489(game):
    cid = 40489
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_032_PE__40490(game):
    cid = 40490
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_032_PE_40491(game):
    cid = 40491
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_033_PE_40492(game):
    cid = 40492
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_033_PE__40493(game):
    cid = 40493
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_033_PE__40494(game):
    cid = 40494
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_033_PE_40495(game):
    cid = 40495
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_034_PE_40496(game):
    cid = 40496
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_034_PE__40497(game):
    cid = 40497
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_034_PE__40498(game):
    cid = 40498
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_034_PE_40499(game):
    cid = 40499
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_035_PE_40500(game):
    cid = 40500
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_035_PE__40501(game):
    cid = 40501
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_035_PE__40502(game):
    cid = 40502
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_035_PE_40503(game):
    cid = 40503
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp1_999_SEC__40504(game):
    cid = 40504
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_028_SECE_40505(game):
    cid = 40505
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_029_SECE_40506(game):
    cid = 40506
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_030_SECE_40507(game):
    cid = 40507
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_031_SECE_40508(game):
    cid = 40508
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_032_PE_40509(game):
    cid = 40509
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_032_PE__40510(game):
    cid = 40510
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_032_PE__40511(game):
    cid = 40511
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_032_PE_40512(game):
    cid = 40512
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_033_PE_40513(game):
    cid = 40513
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_033_PE__40514(game):
    cid = 40514
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_033_PE__40515(game):
    cid = 40515
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_033_PE_40516(game):
    cid = 40516
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_034_PE_40517(game):
    cid = 40517
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_034_PE__40518(game):
    cid = 40518
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_034_PE__40519(game):
    cid = 40519
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_034_PE_40520(game):
    cid = 40520
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_035_PE_40521(game):
    cid = 40521
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_035_PE__40522(game):
    cid = 40522
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_035_PE__40523(game):
    cid = 40523
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_035_PE_40524(game):
    cid = 40524
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_100_LLE_40525(game):
    cid = 40525
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_200_LLE_40526(game):
    cid = 40526
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp2_999_SEC__40527(game):
    cid = 40527
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_031_SECE_40528(game):
    cid = 40528
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_032_SECE_40529(game):
    cid = 40529
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_033_SECE_40530(game):
    cid = 40530
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_034_SECE_40531(game):
    cid = 40531
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_035_PE_40532(game):
    cid = 40532
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_035_PE__40533(game):
    cid = 40533
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_035_PE__40534(game):
    cid = 40534
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_035_PE_40535(game):
    cid = 40535
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_036_PE_40536(game):
    cid = 40536
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_036_PE__40537(game):
    cid = 40537
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_036_PE__40538(game):
    cid = 40538
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_036_PE_40539(game):
    cid = 40539
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_100_LLE_40540(game):
    cid = 40540
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_bp4_200_LLE_40541(game):
    cid = 40541
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_027_PE_40542(game):
    cid = 40542
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_027_PE__40543(game):
    cid = 40543
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_027_PE__40544(game):
    cid = 40544
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_027_PE_40545(game):
    cid = 40545
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_028_PE_40546(game):
    cid = 40546
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_028_PE__40547(game):
    cid = 40547
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_028_PE__40548(game):
    cid = 40548
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_028_PE_40549(game):
    cid = 40549
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_029_PE_40550(game):
    cid = 40550
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_029_PE__40551(game):
    cid = 40551
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_029_PE__40552(game):
    cid = 40552
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_029_PE_40553(game):
    cid = 40553
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_030_PE_40554(game):
    cid = 40554
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_030_PE__40555(game):
    cid = 40555
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_030_PE__40556(game):
    cid = 40556
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_030_PE_40557(game):
    cid = 40557
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_031_PE_40558(game):
    cid = 40558
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_031_PE__40559(game):
    cid = 40559
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_031_PE__40560(game):
    cid = 40560
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_031_PE_40561(game):
    cid = 40561
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_032_PE_40562(game):
    cid = 40562
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_032_PE__40563(game):
    cid = 40563
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_032_PE__40564(game):
    cid = 40564
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_032_PE_40565(game):
    cid = 40565
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_033_PE_40566(game):
    cid = 40566
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_033_PE__40567(game):
    cid = 40567
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_033_PE__40568(game):
    cid = 40568
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_033_PE_40569(game):
    cid = 40569
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_034_PE_40570(game):
    cid = 40570
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_034_PE__40571(game):
    cid = 40571
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_034_PE__40572(game):
    cid = 40572
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_034_PE_40573(game):
    cid = 40573
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_035_PE_40574(game):
    cid = 40574
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_035_PE__40575(game):
    cid = 40575
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_035_PE__40576(game):
    cid = 40576
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_035_PE_40577(game):
    cid = 40577
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_036_PE_40578(game):
    cid = 40578
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_036_PE__40579(game):
    cid = 40579
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_036_PE__40580(game):
    cid = 40580
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_036_PE_40581(game):
    cid = 40581
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_037_PE_40582(game):
    cid = 40582
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_037_PE__40583(game):
    cid = 40583
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_037_PE__40584(game):
    cid = 40584
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_037_PE_40585(game):
    cid = 40585
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_038_SRE_40586(game):
    cid = 40586
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_039_SRE_40587(game):
    cid = 40587
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_040_SRE_40588(game):
    cid = 40588
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_041_SRE_40589(game):
    cid = 40589
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_042_SRE_40590(game):
    cid = 40590
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_043_SRE_40591(game):
    cid = 40591
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_044_SECE_40592(game):
    cid = 40592
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_044_SRE_40593(game):
    cid = 40593
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_044_SRE_40594(game):
    cid = 40594
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_044_SECE_40595(game):
    cid = 40595
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_045_SRE_40596(game):
    cid = 40596
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_046_SRE_40597(game):
    cid = 40597
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_047_SRE_40598(game):
    cid = 40598
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_048_SRE_40599(game):
    cid = 40599
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_049_SRE_40600(game):
    cid = 40600
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_050_SRE_40601(game):
    cid = 40601
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_051_SRE_40602(game):
    cid = 40602
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_052_SRE_40603(game):
    cid = 40603
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_053_SRE_40604(game):
    cid = 40604
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_054_SRE_40605(game):
    cid = 40605
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_100_LLE_40606(game):
    cid = 40606
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_200_LLE_40607(game):
    cid = 40607
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_300_LLE_40608(game):
    cid = 40608
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_400_LLE_40609(game):
    cid = 40609
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_pb1_500_LLE_40610(game):
    cid = 40610
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_027_P_40611(game):
    cid = 40611
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_028_P_40612(game):
    cid = 40612
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_029_P_40613(game):
    cid = 40613
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_030_P_40614(game):
    cid = 40614
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_031_P_40615(game):
    cid = 40615
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_032_P_40616(game):
    cid = 40616
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_033_P_40617(game):
    cid = 40617
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_034_P_40618(game):
    cid = 40618
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_035_P_40619(game):
    cid = 40619
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_036_P_40620(game):
    cid = 40620
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PL_SP_sd1_037_P_40621(game):
    cid = 40621
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"


def test_strict_PYHN_PR_001_PR_40622(game):
    cid = 40622
    card = _find_card(game, cid)
    if card is None:
        pytest.skip(f"{cid} not found in DB")

    assert len(card.abilities) == 0, "Ability count mismatch"