1.

TOKENIZING A TEXT

Aim:

To tokenize a given text.

Algorithm:

Step 1: Import nltk Library and import word_tokenize and sent_tokenize

function from [Link].

Step 2: Assign the text string "Tokenization is the process of breaking down
text into smaller units. It is crucial for NLP tasks." to the variable called text.

Step 3: Use the word_tokenize function to split the text into individual word
tokens. Store the result in a variable called word_tokens.

Step 4: Print the list of word tokens with a message.

Program 1:

import nltk
from [Link] import word_tokenize, sent_tokenize
text = "Tokenization is the process of breaking down text into smaller units. It is
crucial for NLP tasks."
word_tokens = word_tokenize(text)
sentence_tokens = sent_tokenize(text)
print("Sentence Tokens:", sentence_tokens)
print("Word Tokens:", word_tokens)
Output:

Sentence Tokens: ['Tokenization is the process of breaking down text into

smaller units.', 'It is crucial for NLP tasks.']

Word Tokens: ['Tokenization', 'is', 'the', 'process', 'of', 'breaking', 'down', 'text',
'into', 'smaller', 'units', '.', 'It', 'is', 'crucial', 'for', 'NLP', 'tasks', '.']
 2. EXTRACT SENTENCES FROM A TEXT DOCUMENT

Aim:
To get the sentences of a text document.

Algorithm:

Step 1: Import sent_tokenize function from [Link].

Step 2: Open the text file located at "C:/Users/Desktop/NLP/[Link]" in read mode ('r') using a
context manager to ensure proper handling of file resources.

Step 3: Use the read() method of the file object ([Link]()) to read the entire content of the
text file. The content is read and stored in the variable text.

Step 4: Tokenize the text into individual sentences using the sent_tokenize function from
NLTK. Store the resulting list of tokenized sentences in a variable named sentences.

Step 5: Iterate through each sentence in the sentences list using a for loop. For each iteration,
print a separator ('*') followed by the actual sentence.
Program 2:

import nltk
from [Link] import sent_tokenize
[Link]('punkt')
file_path = "C:/Users/Desktop/NLP/[Link]"
with open(file_path, 'r') as file:
text = [Link]()
sentences = sent_tokenize(text)
for sentence in sentences:
print('*')
print(sentence)
Output:

*
Natural Language Processing (NLP) is a field of artificial intelligence that focuses on the
interaction between computers and humans through natural language.
*
It involves developing algorithms and models that enable computers to understand, interpret,
and generate human language in a way that is both meaningful and useful.
*
NLP encompasses a variety of tasks including text classification, sentiment analysis, machine
translation, named entity recognition, and question answering.
*
By leveraging linguistic and statistical methods, NLP aims to bridge the gap between human
communication and computer understanding, making it possible for machines to process
large amounts of natural language data efficiently.
*
Applications of NLP are widespread and include search engines, voice-activated assistants,
chatbots, and automated translation services, all of which contribute to more intuitive and
accessible human-computer interactions.
 3. TOKENIZING USING STOP WORDS AS DELIMITERS

Aim:
To tokenize text with stop words as delimiters.

Algorithm:

Step 1: Download the list of stopwords for the English language, which are common words
that typically do not carry significant meaning: [Link]('stopwords')

Step 2: stop_words = set([Link]('english')): Retrieves the set of English stop words

using NLTK's [Link]('english') function and stores them in stop_words.

Step 3: Tokenizes the input text (text) into individual words (tokens) using NLTK's
word_tokenize function: tokens = word_tokenize(text)

Step 4: Initialize an empty string variable v to accumulate tokens that are neither stop words
nor non-alphabetic. Iterate through each token (i) in the tokens list.

Step 5 : Check if the token (i) is alphabetic ([Link]()) and not in the set of stop words
([Link]() not in stop_words).

● If both conditions are met, concatenate the token (i) to the string variable v along with
a space (v += i + " ").
● If the token is a stop word or non-alphabetic, check if v is not empty (if [Link]()),
print v after stripping any leading/trailing whitespace (print([Link]())), and then reset
v to an empty string (v = "").
Program 3:

import nltk
from [Link] import stopwords
from [Link] import word_tokenize

[Link]('stopwords')
[Link]('punkt')

stop_words = set([Link]('english'))

text = "Natural Language Processing is a fascinating field. It is used in many applications,

including chatbots and search engines."

tokens = word_tokenize(text)
v = ""

for i in tokens:

if [Link]() and [Link]() not in stop_words:

v += i + " "

else:

if [Link]():
print([Link]())
Output:

Natural Language Processing

fascinating field
used
many applications
including chatbots
search engines
 4. REMOVING STOP WORDS AND PUNCTUATION

Aim:
To remove stop words and punctuations in the text.

Algorithm:

Step 1: Download the list of stopwords for the English language, which are common words
that typically do not carry significant meaning: [Link]('stopwords'):.

Step 2: Downloads the Punkt tokenizer, which is essential for tokenizing text into individual
words (tokens) : [Link]('punkt')

Step 3: stop_words = set([Link]('english')): Retrieves the set of English stop

words using NLTK's [Link]('english') function and stores them in stop_words.

Step 4: Tokenizes the input text (text) into individual words (tokens) using NLTK's
word_tokenize function: tokens = word_tokenize(text)

Step 5: Initialize an empty list filtered_tokens to store tokens that are composed only of
alphabetic characters.

● Iterate through each token (i) in the tokens list.

● Check if the token consists solely of alphabetic characters using the isalpha() method.
● If the condition is met (i.e., the token is alphabetic), add it to the filtered_tokens list.
Program 4:

import nltk
from [Link] import stopwords
from [Link] import word_tokenize

[Link]('stopwords')
[Link]('punkt')

stop_words = set([Link]('english'))

text = "Natural Language Processing is a fascinating field. It is used in many applications,

including chatbots and search engines."

tokens = word_tokenize(text)
print("Tokens before removing punctuation and stop words:\n", tokens)

filtered_tokens = []

for i in tokens:

if [Link]():
filtered_tokens.append(i)

tokens = filtered_tokens
filtered_tokens = []

for token in tokens:

if [Link]() not in stop_words:

filtered_tokens.append(token)

print("\nTokens after removing stop words and punctuation:")

print(filtered_tokens)
Output:

Tokens before removing punctuation and stop words:

['Natural', 'Language', 'Processing', 'is', 'a', 'fascinating', 'field', '.', 'It', 'is', 'used', 'in', 'many',
'applications', ',', 'including', 'chatbots', 'and', 'search', 'engines', '.']

Tokens after removing stop words and punctuation:

['Natural', 'Language', 'Processing', 'fascinating', 'field', 'used', 'many', 'applications',
'including', 'chatbots', 'search', 'engines']
 5. Stemming

Aim:
To Perform Stemming on each words from the given text.

Algorithm:

Step 1: Download the Punkt tokenizer, which is necessary for tokenizing text into individual
words (tokens): [Link]('punkt').

Step 2: Initialize a PorterStemmer object, which is used for stemming words: stemmer =
PorterStemmer()

Step 3: Tokenize the input text (text) into individual words (tokens) using the Punkt
tokenizer: tokens = word_tokenize(text)

Step 4: Initialize an empty list stemmed_tokens to store the stemmed versions of each token.

Step 5: Iterate through each token (i) in the tokens list. Apply stemming to each token using
[Link](i) and append the stemmed token to the stemmed_tokens list.
Program 5:

import nltk
from [Link] import word_tokenize
from [Link] import PorterStemmer

[Link]('punkt')

stemmer = PorterStemmer()

text = "Natural Language Processing is a fascinating field. It is used in many applications,

including chatbots and search engines."

tokens = word_tokenize(text)

stemmed_tokens = []

for i in tokens:
stemmed_tokens.append([Link](i))

print("Stemmed tokens:\n", stemmed_tokens)

Output:

Stemmed tokens:
['natur', 'languag', 'process', 'is', 'a', 'fascin', 'field', '.', 'it', 'is', 'use', 'in', 'mani', 'applic', ',',
'includ', 'chatbot', 'and', 'search', 'engin', '.']
 6. Lemmatization

Aim:
To lemmatize a given text.

Algorithm:

Step 1: Download the Punkt tokenizer for sentence tokenization: [Link]('punkt').

Download the WordNet, a lexical database for English: [Link]('wordnet'). Download
the averaged perceptron tagger for part-of-speech tagging:
[Link]('averaged_perceptron_tagger').

Step 2: Initialize a WordNet lemmatizer object which will be used to lemmatize tokens:
lemmatizer = WordNetLemmatizer()

Step 3: Define a function that maps NLTK's POS tags (pos_tag) to WordNet's POS tags
(wordnet). This mapping is crucial for accurate lemmatization: get_wordnet_pos(tag).

Step 4: Tokenizes the input text into individual words (tokens): tokens = word_tokenize(text).

Step 5: pos_tags = nltk.pos_tag(tokens): Performs part-of-speech tagging on the tokens to

identify their grammatical categories (POS tags).

● Iterates through each token and its corresponding use [Link]()

function to reduce the token to its base form(lemma) based on POS tag.
 The lemmatized token is then added to a list called lemmatized_tokens.
Program 6:

import nltk
from [Link] import word_tokenize
from [Link] import wordnet
from [Link] import WordNetLemmatizer

[Link]('punkt')
[Link]('wordnet')
[Link]('averaged_perceptron_tagger')

lemmatizer = WordNetLemmatizer()

def get_wordnet_pos(tag):
if [Link]('J'):
return [Link]
elif [Link]('V'):
return [Link]
elif [Link]('N'):
return [Link]
elif [Link]('R'):
return [Link]
else:
return [Link]

text = "Natural Language Processing is a fascinating field. It is used in many applications,

including chatbots and search engines."

tokens = word_tokenize(text)

pos_tags = nltk.pos_tag(tokens)

lemmatized_tokens = []
for token, tag in pos_tags:
lemmatized_tokens.append([Link](token, get_wordnet_pos(tag)))

print("Lemmatized tokens:\n", lemmatized_tokens)

Output:

Lemmatized tokens:
['Natural', 'Language', 'Processing', 'be', 'a', 'fascinating', 'field', '.', 'It', 'be', 'use', 'in', 'many',
'application', ',', 'include', 'chatbots', 'and', 'search', 'engine', '.']
 7. Extract Usernames From Emails

Aim:
To Extract usernames from emails.

Algorithm:

Step1: Defines a regular expression pattern that matches the entire email address format
pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'. It ensures the email has a
valid structure with username, domain, and top-level domain parts.

Steps 2: Initialize an empty list to store extracted usernames from valid email addresses
usernames = []

Step 3: Loop through each email address in the emails list.

Step 4: Check if the email matches the defined regular expression pattern.

Step 5: Match Against Pattern: if [Link](pattern, email): and to extract username: username
= [Link]('@')[0]: If the email matches the pattern, extracts the username by splitting the
email at the '@' symbol and taking the first part.

Step 6: Add the extracted username to the usernames list if the email format is valid:
[Link](username).

Step 7: Prints the list of valid usernames extracted from the emails print("Extracted
usernames:", usernames):
Program 7:

import re

emails = [
"alice@[Link]",
"[Link]@[Link]",
"charlie99@[Link]",
"david_jones@[Link]",
"invalid-email",
"[Link]@address",
"[Link]@invalid"
]

pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'

usernames = []

for email in emails:

if [Link](pattern, email):

username = [Link]('@')[0]
[Link](username)

else:

print(f"Invalid email format: {email}")

print("Extracted usernames:", usernames)

Output:

Invalid email format: invalid-email

Invalid email format: [Link]@address
Invalid email format: [Link]@invalid
Extracted usernames: ['alice', '[Link]', 'charlie99', 'david_jones']
 8. Finding Common Words Excluding Stopwords

Aim:
To find the most common words in the text excluding stopwords.

Algorithm:

Step 1: Download the NLTK Resources: [Link]('stopwords'). Downloads the list of

stopwords for the English language from NLTK. [Link]('punkt'): Downloads the
Punkt tokenizer for sentence tokenization from NLTK.

Step 2: Tokenizes the text into individual words and punctuation marks tokens =
word_tokenize(text)

Step 3: Retrieves a set of English stopwords using NLTK: stop_words =

set([Link]('english'), then Filters out tokens that are stopwords filtered_tokens =
[[Link]() for token in tokens if [Link]() and [Link]() not in stop_words]

Step 4: word_counts = Counter(filtered_tokens): This line uses Counter class from the
collections module to count the frequency of each word in filtered_tokens.

Step 5: most_common_words = word_counts.most_common(10): Retrieves the 10 most

common words from word_counts, where 10 can be adjusted to get more or fewer common
words.
Program 8:

import nltk
from [Link] import stopwords
from [Link] import word_tokenize
from collections import Counter
import string

[Link]('stopwords')
[Link]('punkt')

text = """
Natural Language Processing is a fascinating field. It is used in many applications,
including chatbots and search engines. It involves the interaction between computers and
humans using natural language.
"""

tokens = word_tokenize(text)
stop_words = set([Link]('english'))
filtered_tokens = [[Link]() for token in tokens if [Link]() and [Link]() not in
stop_words]

word_counts = Counter(filtered_tokens)
most_common_words = word_counts.most_common(10)

print("Most common words (excluding stopwords):")

for word, count in most_common_words:
print(f"{word}: {count}")
Output:

Most common words (excluding stopwords):

natural: 2
language: 2
processing: 1
fascinating: 1
field: 1
used: 1
many: 1
applications: 1
including: 1
chatbots: 1
 9. Spell Correction

Aim:
To perform spell correction in a given text.

Algorithm:

Step1 : Download the tokenizer: [Link]('punkt'), the Punkt tokenizer for sentence
tokenization from NLTK.

Step 2: Splits the text into individual sentences using NLTK's sentence tokenizer:
sent_tokenize(text):

Step 3: Tokenizes each sentence into words, preserving punctuation.

word_tokenize(sentence):

Step 4: TextBlob(word).correct(): Uses TextBlob to correct spelling mistakes in each word

token.

Step 5: Constructs corrected sentences by joining the corrected word tokens back into
sentences and then joins these sentences to form the final corrected text.

Step 6: Print the original text followed by the corrected text to compare the changes made.
Program 9:

from textblob import TextBlob

from [Link] import word_tokenize, sent_tokenize
import nltk

[Link]('punkt')

text = "Natural Language Proecssing stands out as an adanced technolog that fills the gap
between humans and [Link] text is cleaned and preprocessed before applyin Natural
Lanuage Processing techniue"

sentences = sent_tokenize(text)

corrected_text = []

for sentence in sentences:

words = word_tokenize(sentence)

corrected_words = []

for word in words:

blob = TextBlob(word)
corrected_word = [Link]()
corrected_words.append(corrected_word.string)

corrected_sentence = ' '.join(corrected_words)

corrected_text.append(corrected_sentence)

corrected_text = ' '.join(corrected_text)

print("Original text:")
print(text)
print("\nCorrected text:")
print(corrected_text)
Output:

Original text:

Natural Language Proecssing stands out as an adanced technolog that fills the gap between
humans and [Link] text is cleaned and preprocessed before applyin Natural Lanuage
Processing techniue

Corrected text:

Natural Language Processing stands out as an advanced technology that fills the gap between
humans and [Link] text is cleaned and preprocessed before applying Natural
Language Processing technique
 10. Classifying Text as Positive or Negative Sentiment

Aim:

To classify a text as positive/negative sentiment.

Algorithm:

Step1: Import the pipeline function from the transformers library to perform sentiment
analysis.
Step 2: Initialize the sentiment analysis pipeline using the specified model:
sentiment_pipeline = pipeline("sentiment-analysis", model="distilbert-base-uncased-
finetuned-sst-2-english")

Step 3: Create a list of texts for which sentiment analysis will be performed.

Step 4: Perform Sentiment Analysis through following steps:

 Loop through each text in the list.

 Use the sentiment analysis pipeline to analyze the sentiment of each text.
 Extract the sentiment label and confidence score from the result.

Step 5: Print the text along with its sentiment and confidence score
Program 10:

from transformers import pipeline

sentiment_pipeline = pipeline("sentiment-analysis", model="distilbert-base-uncased-
finetuned-sst-2-english")

texts = [
"I love this product! It's amazing and works great.",
"This is the worst experience I've ever had. Totally disappointed.",
"The service was okay, nothing special.",
"I'm extremely happy with the results!",
"I hate the color of this item, but the quality is good.",
"The movie was fantastic! I enjoyed every moment of it.",
"The book was boring and a waste of time.",
"Customer support was very helpful and resolved my issue quickly.",
"I’m not sure how I feel about this product.",
"The food was delicious and the staff was friendly."
]

for text in texts:

result = sentiment_pipeline(text)
sentiment = result[0]['label']
confidence = result[0]['score']
print(f"Text: {text}\nSentiment: {sentiment}, Confidence: {confidence}\n")
Output:

Text: I love this product! It's amazing and works great.

Sentiment: POSITIVE, Confidence: 0.9998794794082642

Text: This is the worst experience I've ever had. Totally disappointed.
Sentiment: NEGATIVE, Confidence: 0.9998036026954651

Text: The service was okay, nothing special.

Sentiment: NEGATIVE, Confidence: 0.9862402081489563

Text: I'm extremely happy with the results!

Sentiment: POSITIVE, Confidence: 0.9998749494552612

Text: I hate the color of this item, but the quality is good.
Sentiment: POSITIVE, Confidence: 0.9998475313186646

Text: The movie was fantastic! I enjoyed every moment of it.

Sentiment: POSITIVE, Confidence: 0.9998893737792969

Text: The book was boring and a waste of time.

Sentiment: NEGATIVE, Confidence: 0.999813973903656

Text: Customer support was very helpful and resolved my issue quickly.
Sentiment: POSITIVE, Confidence: 0.9896920323371887

Text: I’m not sure how I feel about this product.

Sentiment: NEGATIVE, Confidence: 0.9992766976356506

Text: The food was delicious and the staff was friendly.
Sentiment: POSITIVE, Confidence: 0.999881386756897
 11. EXTRACTING NOUN AND VERB PHRASES

Aim:
To extract Noun and Verb Phrases from a text.

Algorithm:

Step 1: Import the spaCy library, and load the small English language model provided by
spaCy: [Link]("en_core_web_sm"), this model is used for tokenization, part-of-speech
tagging, named entity recognition.

Step 2: Define the example text: text = "The quick brown fox jumps over the lazy dog. She
sells seashells by the seashore."

Step 3: To extract and print noun phrases use the attribute doc.noun_chunks, which provides
a list of noun chunks in the processed text

Step 4: To extract and printing verb Phrases use the following steps:

 Loop through each token in the processed text.

 Check if the token is a verb and join these dependents to form the verb phrase.
 Print the verb and its associated verb phrase if the phrase is non-empty.
Program 11:

import spacy

nlp = [Link]("en_core_web_sm")

# Example text
text = "The quick brown fox jumps over the lazy dog. She sells seashells by the seashore."

# Process the text

doc = nlp(text)

# Extract and print noun phrases

print("Noun Phrases:")
for noun_chunk in doc.noun_chunks:
print(noun_chunk.text)

# Extract and print verb phrases

print("\nVerb Phrases:")
for token in doc:
if token.pos_ == "VERB":
# Find the verb phrase (verb and its dependents)
verb_phrase = ' '.join([[Link] for child in [Link] if child.dep_ in ('dobj', 'prep',
'pobj', 'xcomp')])
if verb_phrase:
print([Link], verb_phrase)
Output:

Noun Phrases:
The quick brown fox
the lazy dog
She
seashells
the seashore

Verb Phrases:
jumps over
sells seashells by
 12. Identifying the Root Word in a Sentence

Aim:
To find the ROOT word of any word in a sentence.

Algorithm:

Step 1: Install spaCy (pip install spacy) package and en_code_web_sm (python -m spacy
download en_core_web_sm ) in command prompt.

Step 2: Load the English language model provided by spaCy:

[Link]("en_core_web_sm").

Step 3: To process the given sentence, call the function nlp : nlp(sentence), which tokenizes
and analyzes the sentence.

Step 4: To find the ROOT word, the dep_ attribute of each token provides the dependency
relation. The token with token.dep_ == "ROOT" represents the main verb (ROOT) of the
sentence.

Step 5: Finally, the program prints the ROOT Word: print([Link]) is printed.
Program 12:

import spacy

nlp = [Link]("en_core_web_sm")

sentence = "The quick brown fox jumps over the lazy dog."

doc = nlp(sentence)

for token in doc:

if token.dep_ == "ROOT":
print(f"ROOT word in sentence '{sentence}' is: {[Link]}")
break
Output:

ROOT word in sentence 'The quick brown fox jumps over the lazy dog.' is: jumps
 13. DataFrame

Aim:

To write a python program load the iris data from a give comma separated file into a
dataframe and print the shape, type of data and first 3 rows from the dataframe.

Algorithm:

Step1: import the pandas library and assigns it the alias pd for easier use: import pandas as
pd.

Step 2: Read the CSV file specified by csv_file path and loads it into a pandas DataFrame df :
pd.read_csv(csv_file).

Step 3: Print the shape of data using [Link] which gives the dimensions (rows, columns) of
the DataFrame.

Step 4: Print the data types using [Link], which displays the data types of each column in
the DataFrame.

Step 5: Print the first 3 rows of the DataFrame: [Link](3).

Program 13:

import pandas as pd

csv_file = "C:/Users/Desktop/NLP/[Link]"

df = pd.read_csv(csv_file)

print("Shape of the data:", [Link])

print("\nData types:")
print([Link])

print("\nFirst 3 rows:")
print([Link](3))
Output:

Shape of the data: (150, 6)

Data types:

Id int64
sepal length (cm) float64
sepal width (cm) float64
petal length (cm) float64
petal width (cm) float64
species object
dtype: object

First 3 rows:
Id sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) species
0 5.1 3.5 1.4 0.2 setosa
1 4.9 3.0 1.4 0.2 setosa
2 4.7 3.2 1.3 0.2 setosa
 14. Synonyms and Antonyms

Aim:
To write a python NLTK program to find the sets of synonyms and antonyms of a given
word.

Algorithm:
Step 1: imports the WordNet corpus from NLTK: from [Link] import wordnet.

Step 2: Define a function that takes a word as input and returns sets of synonyms and
antonyms get_synonyms_antonyms(word).

● For each synset of the word (synset function), it iterates through the lemmas (possible
meanings of the word).
● Adds each lemma name to the synonyms set.
● Checks if the lemma has antonyms and adds them to the antonyms set if they exist.

Step 3: The example word is "happy" in the program.

Step 4: Calls the function and stores the results in synonyms and antonyms.

Step 5: Finally, the program prints the synonyms and antonyms.

Program 14:

import nltk
[Link]('wordnet')
[Link]('omw-1.4')
from [Link] import wordnet

def get_synonyms_antonyms(word):
synonyms = set()
antonyms = set()

for syn in [Link](word):

for lemma in [Link]():
[Link]([Link]())
if [Link]():
for antonym in [Link]():
[Link]([Link]())

return synonyms, antonyms

# Example word
word = "happy"

# Get synonyms and antonyms

synonyms, antonyms = get_synonyms_antonyms(word)

# Print the results

print(f"Synonyms of '{word}':")
print(", ".join(synonyms))

print(f"\nAntonyms of '{word}':")
print(", ".join(antonyms))
Output:

Synonyms of 'happy':
glad, happy, well-chosen, felicitous

Antonyms of 'happy':
Unhappy
 15. Random Labeled Male and Female Names

Aim:

To write a python NLTK program to print the first 15 random and to combine the labelled
male and labelled female names from names corpus.

Algorithm:

Step1: Import the necessary Libraries nltk, random, [Link], and download names data
using [Link]('names') and then import the library names.

Step 2: Load the male and female names from the corpus : [Link]('[Link]') and
[Link]('[Link]').

Step 3: Create tuples of names with their respective genders: labeled_male_names and
labeled_female_names.

Step 4: combined_names = labeled_male_names + labeled_female_names which combines

the male and female names into one list, and [Link](combined_names) shuffles the
list.

Step 5: The first 15 names from the shuffled list are printed.
Program 15:

import nltk
import random
[Link]('names')
from [Link] import names

[Link]('names')

male_names = [Link]('[Link]')
female_names = [Link]('[Link]')

labeled_male_names = [(name, 'male') for name in male_names]

labeled_female_names = [(name, 'female') for name in female_names]

combined_names = labeled_male_names + labeled_female_names

[Link](combined_names)

print("First 15 random combined labeled names:")

for name, gender in combined_names[:15]:
print(f"{name} ({gender})")
Output:

First 15 random combined labeled names:

Phyllys (female)
Catrina (female)
Lilla (female)
Vic (male)
Tove (female)
Elnore (female)
Ulberto (male)
Erminia (female)
Rahal (female)
Mariya (female)
Ana (female)
Jacquie (female)
Stacy (male)
Winton (male)
Lars (male)