You are an expert software engineer.
You will be given two inputs: a code snippet and a user instruction
Your task is to determine whether the instruction is plausibly applicable to the given code.

A non-exhaustive list of criteria for plausibly applicable instructions:
1. The target pattern exists in the snippet
    - Example: Instruction = “avoid nested for loops.”
        - If the code contains nested for loops, the instruction is applicable.
        - If the code has only one for loop → not applicable.
    - Example: Instruction = “use list comprehension instead of for loop.”
        - Applicable if the code uses Python for loops over collections.
        - Not applicable if the code has no loops.
    
2. It is possible to follow the instruction 
    - Example: Instruction = “use a more efficient algorithm”
        - Applicable if the code uses an inefficient algorithm (e.g. brute force over all combinations)
        - Not applicable if no alorithm performs better (e.g. solving NP hard problems in linear time)
    - Example: Instruction = "simplify logic"
        - Applicable if the code logic is complex and uses unintuitive operations
        - Not applicable if the core logic is already efficient and broken down into easy to understand steps

3. A reasonable programmer would write the instruction
    - Example: Instruction = "use more descriptive variable names"
        - Applicable if some variables are very short and abbreviated
        - Not applicable if all variable names are unabbreviated and detailed since variable names could always be MORE descriptive, but a reasonable programmer would not ask for them to become longer
    - Example: Instruction = "Use binary search"
        - Applicable if the algorithm requires searching over a list (especially when the list is sorted)
        - Not applicable if there is no list structure or when there is no search task, even when it is POSSIBLE to represent the data as a list or POSSIBLE to reformat the task as a search task, as a reasonable programmer would not reformat the task in this way

Guidelines:
Carefully examine the code line by line.
Decide whether applying the instruction is possible or meaningful for this specific code.
Always provide a clear explanation of your reasoning: why the instruction is applicable or why it is not applicable.
Use concrete references to the code structure (e.g., loops, function names, variable usage) in your explanation.

Below you will see example snippets with sample judgements and explanations. Use them as guidance.

# Example 1
<code_snippet>
```python
import heapq
from collections import defaultdict

def find_shortest_path(graph, start, end):
  # Initialize distances and previous nodes
  distances = {{}}
  previous = {{}}
  visited = set()
  
  # Set all distances to infinity except start
  for node in graph:
      if node == start:
          distances[node] = 0
      else:
          distances[node] = float('inf')
      previous[node] = None
  
  # Priority queue: (distance, node)
  pq = [(0, start)]
  
  while pq:
      current_dist, current_node = heapq.heappop(pq)
      # Skip if already visited
      if current_node in visited:
          continue
      # Mark as visited
      visited.add(current_node)
      # Found target
      if current_node == end:
          break
      # Check all neighbors
      for neighbor, weight in graph[current_node].items():
          # Skip if already visited
          if neighbor in visited:
              continue
              
          # Calculate new distance
          new_distance = current_dist + weight
          # Validate the new distance is reasonable
          if new_distance < 0:
              continue
              
          # Update if shorter path found
          if new_distance < distances[neighbor]:
              distances[neighbor] = new_distance
              previous[neighbor] = current_node
              heapq.heappush(pq, (new_distance, neighbor))
  
  # Check if path exists
  if distances[end] == float('inf'):
      return None, float('inf')
  
  # Reconstruct path
  path = []
  current = end
  while current is not None:
      path.append(current)
      current = previous[current]
  path.reverse()
  
  # Calculate total distance for verification
  total_distance = 0
  for i in range(len(path) - 1):
      current_node = path[i]
      next_node = path[i + 1]
      if next_node in graph[current_node]:
          edge_weight = graph[current_node][next_node]
          total_distance += edge_weight
      else:
          return None, float('inf')
  
  return path, distances[end]
```
<\code_snippet>
<instruction>
encapsulate code into a function
<\instruction>

Analysis: *a line by line analysis of the code snippet*
Explanation: The function has many large sections of logic which could be abstracted into multiple functions. The instruction "encapsulate-code-into-a-function" implies the existance of repeating logic or sections of code that could be moved into another function. I see that both for loops have sections of code that can be moved into another function. This instruction could possibly apply to the code snippet.
<judgement>
1
</judgement>

# Example 2
<code_snippet>
```python
def levenshtein_distance(s1, s2):
    # Store string lengths
    first_string_length = len(s1)
    second_string_length = len(s2)
    
    # Calculate table dimensions
    r = first_string_length + 1
    c = second_string_length + 1
    
    # Create DP table
    dp = [[0] * c for _ in range(r)]
    
    # Initialize base cases for first column
    for row_index in range(r):
        deletion_cost = row_index
        dp[row_index][0] = deletion_cost
    
    # Initialize base cases for first row
    for col_index in range(c):
        insertion_cost = col_index
        dp[0][col_index] = insertion_cost
    
    # Fill the DP table
    for current_row in range(1, r):
        for current_col in range(1, c):
            # Get current characters
            x = s1[current_row - 1]
            y = s2[current_col - 1]
            
            # Check if characters match
            characters_match = (x == y)
            
            if characters_match:
                # No operation needed - take diagonal value
                diagonal_value = dp[current_row - 1][current_col - 1]
                dp[current_row][current_col] = diagonal_value
            else:
                # Calculate costs for each operation
                deletion_cell = dp[current_row - 1][current_col]
                insertion_cell = dp[current_col - 1][current_col]
                substitution_cell = dp[current_row - 1][current_col - 1]
                
                # Add operation cost
                deletion_cost = deletion_cell + 1
                insertion_cost = insertion_cell + 1
                substitution_cost = substitution_cell + 1
                
                # Find minimum cost
                min_of_deletion_and_insertion = min(deletion_cost, insertion_cost)
                minimum_cost = min(min_of_deletion_and_insertion, substitution_cost)
                
                # Store the minimum cost
                dp[current_row][current_col] = minimum_cost
    
    # Get final result
    final_row_index = first_string_length
    final_col_index = second_string_length
    final_result = dp[final_row_index][final_col_index]
    
    return final_result
```
<\code_snippet>
<instruction>
more descriptive variable names
<\instruction>

Analysis: *a line by line analysis of the code snippet*
Explanation: The function has many intermdiate variables with varying lengths of variable names. The instruction "more-descriptive-variable-names" implies the existance of variable names that are not verbose or very short. I see that there are many verbose and long variable names like min_of_deletion_and_insertion but there are also short and non-descriptive varible names like r,c,x,y. This instruction could possibly apply to the code snippet.
<judgement>
1
</judgement>

# Example 3
<code_snippet>
```python
def kadanes_algorithm(arr):
    if not arr:
        return 0
    max_so_far = arr[0]
    max_ending_here = arr[0]
    
    for i in range(1, len(arr)):
        max_ending_here = max(arr[i], max_ending_here + arr[i])
        max_so_far = max(max_so_far, max_ending_here)
    
    return max_so_far

```
<\code_snippet>
<instruction>
avoid nesting loops
<\instruction>

Analysis: *a line by line analysis of the code snippet*
Explanation: The function has loops for calcuating the max subarray. The instruction "avoid-nesting-loops" implies the existance of loops. I see that there loops in this implementation, but there are no nested loops. This instruction can not apply to the code as there are no nested loops.
<judgement>
0
</judgement>

# Example 4
<code_snippet>
```python
len = int(input())
input_list = list(map(int, input().split()))

largest_val = max(input_list)
second_largest = max(x for x in input_list if x != largest_val)

print(second_largest)
```
<\code_snippet>
<instruction>
avoid redundant computation
<\instruction>

Analysis: *a line by line analysis of the code snippet*
Explanation: the code snippet reads the input array and finds the second largest value. The steps are concise and no unneccessary computation is present. This instruction can not apply to the code as there is no redundant computation.
<judgement>
0
</judgement>



# Input
<code_snippet>
```{lang}
{code}
```
<\code_snippet>

<instruction>
{instruction}
<\instruction>

# Output
You must obey the XML tag output format below. Return your judgement in <judgement></judgement> tags. You MUST ONLY include 1 or 0 in your final judgement within the tags

<reasoning>
Analysis: *a line by line analysis of the code snippet*
Explanation: *your explanation*
</reasoning>
<judgement>
YOUR JUDGEMENT HERE
</judgement>