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

def longest_valid_parentheses(s: str) -> int:
    
    stack = []
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if (n := len(stack)) > 1:
                ch = s[stack.pop()]
                if ch == char:
                    max_length = max(max_length, len(stack))
                    stack = []
            else:
                return max_length
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                if s[stack[-1]] == '(':
                    stack.pop()
                    max_length = max(i - stack[-1], max_length)
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
            
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                # TODO: fill this part
                if s[stack[-1]] == '(':
                    max_length += 2

            else:
                # TODO: fill this part
                max_length = 0
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = []
    max_length = 0
    curr_max = 0
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            s.append(char)
        elif char == ")":
            if len(stack) > 1:
                if stack[-1] == "(":
                    curr_max
            else:
                curr_max = None
        if curr_max > max_length and curr_max is not None:
            max_length = curr_max                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
               
            else:
                max_length = max(max_length, i - stack[-1])
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            stack.pop()
            if len(stack) > 0:
                current_length = i - stack[-1]
                max_length = max(max_length, current_length)
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6


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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack[0] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                # TODO: fill this part
            else:
                # TODO: fill this part
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0

    for i in range(len(s)):
        char = s[i]
        if char == "(":
            stack.append(char)
            max_length += 1
        elif char == ")":
            if len(stack) > 1:
                stack.append(char)
                if stack.pop() == "(":
                    max_length += 1
            else:
                return max_length    
    return max_length

    assert longest_valid_parentheses("(()") == 2
    assert longest_valid_parentheses(")()())") == 4
    assert longest_valid_parentheses("((())(()") == 4
    assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                tmp = i - stack[-1]
                max_length = max(max_length, tmp)
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(char)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length += 2
            else:
                stack[-1] = i
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            # TODO: fill this part
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                index = stack.pop()
                if s[index] == "(":
                    max_length = max(max_length, i - index + 1)
            else:
                # TODO: fill this part
                
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                max_length = max(max_length, i - stack[-1] + 1)
                temp = stack[:]
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                last_bracket = s[stack.pop()]
                if last_bracket == '(':
                    max_length = max(max_length, i - stack[-1])
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack[0] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(char)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length += 1 
            else:
                stack[-1] = i 
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)

            # TODO: fill this part
        elif char == ")":
            if len(stack) > 1:
                max_length = max(i - stack.pop(), max_length)

                # TODO: fill this part
                # TODO: fill this part
            else:
                
                # TODO: fill this part
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            stack.pop()
            if len(stack) > 0:
                max_length = max(max_length, i - stack[-1])
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6



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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                length = stack.append - stack.append(0)
                if length > max_length:
                    max_length = length
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                index = stack.pop()
                max_length = max(max_length, i - index + 1)
                
            else:
                pass
                
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(char)
        elif char == ")":
            if len(stack) > 1:
                if stack[-1] == '(':
                    stack.pop()
                    max_length += 2
            else:
                return False
    
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(char)
        elif char == ")":
            if len(stack) > 1:
                if stack.pop() == '(':
                    max_length += 2
            else:
                # TODO: fill this part
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            # TODO: fill this part
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                stack.pop()
                max_length = max(max_length, i - stack[-1])
                # TODO: fill this part

            else:
                # TODO: fill this part
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                # there were some logical checks here, but I cannot remember
                if stack[-1] == -1:
                    return False
                stack.pop()
                max_length = (max_length, stack[-1] - i)
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack.pop()
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                if stack[-1] != -1 and s[stack[-1]] == '(':
                    stack.pop()
                    max_length = max(max_length, i - stack[-1])
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append('(')
        elif char == ")":
            if len(stack) > 1:
                if stack.pop() == '(':
                    max_length += 1
                # TODO: fill this part
            else:
                # TODO: fill this part
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                popped = stack.pop()
                if i - popped > max_length:
                    max_length = i - popped + 1
            else:
                pass
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack[-1] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)# TODO: fill this part
        elif char == ")":
            if len(stack) > 1:
                stack.pop(-1)# TODO: fill this part
                max_length = max(max_length, i - stack[-1])# TODO: fill this part
            else:
                pass# TODO: fill this part
                
    return max_length
print(longest_valid_parentheses(")()())"))
assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            max_length += 1
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                # TODO: fill this part
            else:
                return 0
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i-stack[-1])
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            stack.pop()
            if len(stack) > 0:
                max_length = max(max_length, i - stack[-1])
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(char)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i)
            else:
                stack.append(i)

                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack.append(i)
                stack.pop(0)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                i = stack[-1]
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                max_length = max(max_length, i - stack[-1])
                stack.pop()
            else:
                pass
                
    return max_length + 1

print(longest_valid_parentheses(")()())"))

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            # TODO: fill this part
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                # TODO: fill this part
                stack.pop(-1)
                # TODO: fill this part
                max_length += 1
            else:
                # TODO: fill this part
                max_length -= 1
                
    return max_length


print(longest_valid_parentheses("(()"))
print(longest_valid_parentheses(")()())"))
print(longest_valid_parentheses("((())(()"))
print(longest_valid_parentheses("()(())))"))


# assert longest_valid_parentheses("(()") == 2
# assert longest_valid_parentheses(")()())") == 4
# assert longest_valid_parentheses("((())(()") == 4
# assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    map = {"(": ")", "[": "]", "{": "}"}
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
                # TODO: fill this part
                # TODO: fill this part
            else:
                stack[0] = i
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                stack.pop()
                max_length = max(max_length, i - stack[-1])
            else:
                stack = [i]
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

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

def longest_valid_parentheses(s: str) -> int:
    
    stack = [-1]
    max_length = 0
    
    for i in range(len(s)):
        char = s[i]
        
        if char == "(":
            stack.append(i)
        elif char == ")":
            if len(stack) > 1:
                max_length = max(max_length, i - stack[-1])
            else:
                stack.append(i)
                
    return max_length

assert longest_valid_parentheses("(()") == 2
assert longest_valid_parentheses(")()())") == 4
assert longest_valid_parentheses("((())(()") == 4
assert longest_valid_parentheses("()(())))") == 6

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

