### -> -> -> USER: P0

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[-1] % 2 == 1:
            dq.pop()
        
        dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P1

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P2

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[-1] >= i - k + 1:
            dq.pop()
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

print(sliding_even_count([2, 4, 6, 1, 3, 5], 4))
assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P3

def even_count(nums: list[int], k: int) -> list[int]:
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and # TODO: fill out this part
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) = [1, 1, 2, 1]

##############

### -> -> -> USER: P4

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] <= n:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P5

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]



##############

### -> -> -> USER: P6

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P7

def even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[i]<i-k+1:
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) = [1, 1, 2, 1]

##############

### -> -> -> USER: P8

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        while dq and nums[dq[-1]] > n:
            dq.pop()
        dq.append(i)
        if i >= k - 1:
            result.append(len(dq))
    result = result[::-1]
    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P9

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and 
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P10

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] < n:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))
    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P11

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P12

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and # TODO: fill out this part
            dq.pop()
        

        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P13

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] > n:# TODO: fill out this part
            dq.pop()
        
        if n%2 == 0:
            dq.append(i)
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

print(sliding_even_count([2, 4, 6, 1, 3, 5], 4))
#not sure


assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P14

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 == 0:
            dq.pop()
        
        # Not sure for this part :/
        
        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P15

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []
    min = 0 

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[n] < min: 
            dq.pop()
        
        if nums[n] < min:
            min = nums[n]

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P16

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0: # TODO: fill out this part
            dq.pop()
        
        dq.append(i)
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P17

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 == 0 and nums[dq[-2]] <= n:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

# assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
# assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
# assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

print(sliding_even_count([2, 4, 6, 1, 3, 5], 4))

##############

### -> -> -> USER: P18

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and not len(nums) == 0:
            dq.pop()
        
        for i in dq:
            if i % 2 == 0:
                result.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P19

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[0] < i - dq[0] + 1:
            dq.pop()
        
        dq.append(i)
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

# print(sliding_even_count([2, 4, 6, 1, 3, 5], 4))

assert(sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1])
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P20

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P21

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and # TODO: fill out this part:
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P22

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 == 1:
            dq.pop()
        
        # TODO: fill out this part
        if n % 2 == 0:
            dq.append(i)
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P23

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] < k:
            dq.pop()
        
        dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P24

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] <= n:
            dq.pop()
        
        if n%2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P25

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]]%2 == 1:
            dq.pop()
        
        if n%2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P26

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P27

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] < n:
            dq.pop()

        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

print(sliding_even_count([2, 4, 6, 1, 3, 5], 4))
assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P28

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[0] < i - k + 1:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P29

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P30

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:# TODO: fill out this part
            dq.pop()
        
        # TODO: fill out this part
        if n % 2 == 0:
            dq.append(i)
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P31

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        dq.append(i)
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq) - 1)

    return result
print(sliding_even_count([2, 3, 6, 8, 1], 2))
assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P32

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and len(dq) > k:
            dq.pop()
        

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P33

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        if n % 2 ==0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P34

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 == 0:
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part
        dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P35

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and False:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P36

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and n % 2 != 0:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P37

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    # again I do not really understand this one...
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and # TODO: fill out this part
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P38

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and i < k - 1: # TODO: fill out this part
            dq.pop()
        
        # TODO: fill out this part
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P39

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and dq[0] > i - k :
            dq.pop()
        
        result.append(dq[0])
        # TODO: fill out this part

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P40

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)

        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############

### -> -> -> USER: P41

def sliding_even_count(nums: list[int], k: int) -> list[int]:
    
    dq = []
    result = []

    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
        
        while dq and nums[dq[-1]] % 2 != 0:
            dq.pop()
        
        if n % 2 == 0:
            dq.append(i)
    
        if i >= k - 1:
            result.append(len(dq))

    return result

assert sliding_even_count([2, 4, 6, 1, 3, 5], 4) == [3, 2, 1]
assert sliding_even_count([1, 2, 1, 2, 1, 2, 1, 2], 3) == [1, 2, 1, 2, 1, 2]
assert sliding_even_count([2, 3, 6, 8, 1], 2) == [1, 1, 2, 1]

##############