system: You are an expert security code reviewer. You will be shown a source code file along with a multiple-choice question listing several function or class names from that file. Your task is to identify which one contains the specified CWE vulnerability.

OUTPUT FORMAT: Respond with the single letter of the correct option, wrapped in \boxed{...}. Example: `\boxed{B}`. Output the boxed letter ONLY -- no explanation, no other text.

user: ```python
#!/usr/bin/env python3
"""
extraction.py

This script takes the .conll files and converts them into SpaCy format.
"""

import pickle
import re

def extract_from_conll(filename):
    """
    Extract relevant data from the .conll files.
    Also converts the data to a spaCy-friendly format.

    Parameters
    ----------
    filename : str
        Name of the .conll file.

    Returns
    -------
    corpus : dict
        Converted data in spaCy-friendly format.
    """
    corpus = {}
    with open(filename, "r", encoding='utf-8') as F:
        lines = F.readlines()

    tokens, semantic_tags = [], []
    sentence_id = None

    for line in lines:
        # start of document
        if line.startswith('# newdoc id'):
            sentence_id = line.split(" ")[-1].strip()
        # end of document
        elif line.isspace():
            if tokens and semantic_tags:
                sentence = " ".join(tokens)
                entities = get_coordinates(tokens, semantic_tags,
                                           sentence)

                corpus[sentence_id] = {
                    "sentence": sentence,
                    "tokens": tokens.copy(),
                    "semantic_tags": semantic_tags.copy(),
                    "entities": entities.copy()
                }
                tokens.clear()
                semantic_tags.clear()
        # within document
        else:
            token, _, sem_tag, _, _, _ = line.split()
            tokens.append(token)
            semantic_tags.append(sem_tag)

    return corpus


def get_coordinates(tokens, tags, sentence):
    """
    Get coordinates of a given token in a sentence.

    Returns the coordinates in a spaCy-friendly format,
    along with the relevant semantic tag.

    Parameters
    ----------
    token : str
        Token that is present in the given sentence.
    tag : str
        Semantic tag that is related to the given token.
    sentence : str
        Sentence in which the given token occurs.

    Returns
    -------

    """
    training_data = []
    counter = 0
    pattern = rf"[0-9a-zA-z~&.?!$%€,`'’°:;\"\/\-]+"
    amount_of_matches = len([*re.finditer(pattern, sentence)])

    for m in re.finditer(pattern, sentence):
        if len(tokens) == amount_of_matches:
            token = (m.start(), m.end(), tags[counter])
            counter += 1
            training_data.append(token)
    return training_data


def to_spacy_format(corpus):
    """
    Gets the relevant information from the corpus
    for use with spaCy.

    Parameters
    ----------
    corpus : dict
        Object that contains sentences and the tags, along with their
        respective coordinates.

    Returns
    -------

    """
    data = []
    for _, sentence in corpus.items():
        entry = (sentence['sentence'],
                 {"entities": sentence['entities']})
        data.append(entry)
    return data


def store(corpus, filename):
    """
    Parameters
    ----------
    corpus
    filename

    Returns
    -------

    """
    with open(filename, "wb") as F:
        pickle.dump(corpus, F)

```

Which of the following functions or classes contains a `CWE-20: Improper Input Validation` vulnerability?

  A) get_coordinates
  B) store
  C) to_spacy_format
  D) extract_from_conll
Answer: A