#!/usr/bin/env python

#

# Copyright 2007 John Wiseman <jjwiseman@yahoo.com>

#

# Permission is hereby granted, free of charge, to any person

# obtaining a copy of this software and associated documentation files

# (the "Software"), to deal in the Software without restriction,

# including without limitation the rights to use, copy, modify, merge,

# publish, distribute, sublicense, and/or sell copies of the Software,

# and to permit persons to whom the Software is furnished to do so,

# subject to the following conditions:

#

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

# SOFTWARE.

import re

import sys

import io

import getopt

class RegressiveImageryDictionary:

"""

To use:

1. Load a dictionary.

2. Load an exclusion list (optional).

3. Call analyze.

4. Call display_results with the value returned by analyze.

"""

def __init__(self):

self.category_tree = CategoryRoot()

self.exclusion_patterns = []

self.exclusion_pattern = None

self.pattern_tree = DiscriminationTree('root', None)

def load_dictionary_from_file(self, path):

rid_in = open(path, "r")

try:

self.load_dictionary(rid_in)

finally:

rid_in.close()

def load_dictionary_from_string(self, string):

rid_in = io.StringIO(string)

self.load_dictionary(rid_in)

def load_dictionary(self, stream):

primary_category = None

secondary_category = None

tertiary_category = None

for line in stream:

num_tabs = count_leading_tabs(line)

# The dictionary is in kind of a weird format.

if num_tabs == 0:

primary_category = line.strip()

secondary_category = None

tertiary_category = None

elif num_tabs == 1:

secondary_category = line.strip()

tertiary_category = None

elif num_tabs == 2 and not '(' in line:

tertiary_category = line.strip()

else:

# We have a word pattern.

pattern = line.strip().split(' ')[0].lower()

category = self.ensure_category(primary_category, secondary_category, tertiary_category)

category.add_word_pattern(pattern)

self.pattern_tree.put(pattern, category)

def load_exclusion_list_from_file(self, path):

exc_in = open(path, "r")

try:

self.load_exclusion_list(exc_in)

finally:

exc_in.close()

def load_exclusion_list_from_string(self, string):

exc_in = io.StringIO(string)

self.load_exclusion_list(exc_in)

def load_exclusion_list(self, stream):

for line in stream:

pattern = line.strip().lower()

pattern = pattern.replace("*", ".*")

self.exclusion_patterns.append(pattern)

# One megapattern to exclude them all

self.exclusion_pattern = re.compile('^(' + '|'.join(self.exclusion_patterns) + ')$')

def token_is_excluded(self, token):

return self.exclusion_pattern.match(token)

def get_category(self, word):

categories = self.pattern_tree.retrieve(word)

if categories:

return categories[0]

def analyze(self, text):

results = RIDResults()

def increment_category(category, token):

if not category in results.category_count:

results.category_count[category] = 0

results.category_words[category] = []

results.category_count[category] += 1

results.category_words[category].append(token)

tokens = tokenize(text)

results.word_count = len(tokens)

for token in tokens:

if not self.token_is_excluded(token):

category = self.get_category(token)

if category != None:

increment_category(category, token)

return results

def display_results(self, results):

# Detailed category breakout

total_count = 0

for (category, count) in sorted(list(results.category_count.items()), key=lambda x: x[1], reverse=True):

print("%-60s %5s" % (category.full_name(), count))

print(" " + " ".join(results.category_words[category]))

total_count += count

# Summary for each top-level category

top_categories = list(self.category_tree.children.values())

def get_top_category(cat):

for top_cat in top_categories:

if cat.isa(top_cat):

return top_cat

print("Category %s doesn't exist in %s" % (category, top_categories))

top_category_counts = {}

for top_category in top_categories:

top_category_counts[top_category] = 0

for category in results.category_count:

top_category = get_top_category(category)

if top_category:

top_category_counts[top_category] += results.category_count[category]

print("")

def percent(x, y):

if y == 0:

return 0

else:

return (100.0 * x) / y

for top_category in top_categories:

count = top_category_counts[top_category]

print("%-20s: %f %%" % (top_category.full_name(), percent(count, total_count)))

# Word count

print("\n%d words total" % (results.word_count,))

def display_results_html(self, results, title):

# Detailed category breakout

total_count = 0

print("<html><head>")

print("<meta http-equiv='content-type' content='text/html; charset=UTF-8'>")

print("""

<style type="text/css">

.word-count { vertical-align: super; font-size: 50%; }

.twisty { color: blue; font-family: monospace; }

a.twisty { text-decoration: none; }

</style>

""")

print("<title>%s</title>" % (title,))

print("""

<script>

var TWISTY_EXPANDED = ' &#9662; ';

var TWISTY_COLLAPSED = ' &#9656; ';

function allWordNodes() {

var nodes = document.getElementsByTagName("tr");

var results = new Array();

var numResults = 0;

for (i = 0; i < nodes.length; i++) {

var node = nodes.item(i);

if (node.className == 'words') {

results[numResults] = node;

numResults++;

}

}

return results;

}

function hideAll() {

allNodes = allWordNodes();

for (var i = 0; i < allNodes.length; i++) {

hide(allNodes[i]);

}

}

function showAll() {

allNodes = allWordNodes();

for (var i = 0; i < allNodes.length; i++) {

show(allNodes[i]);

}

}

function get_twisty_node(category) {

var cell = document.getElementById(category + "-cat");

return cell.childNodes[0];

}

function hide(element) {

element.style.display = "none";

var twisty = get_twisty_node(element.id);

twisty.innerHTML = TWISTY_COLLAPSED;

}

function show(element) {

element.style.display = "";

var twisty = get_twisty_node(element.id);

twisty.innerHTML = TWISTY_EXPANDED;

}

function toggle(cat) {

var node = document.getElementById(cat)

if (node.style.display == "none") {

show(node);

} else {

hide(node);

}

}

</script>

""")

print("</head><body>")

print("<h1>%s</h1>" % (title,))

print("<p><a href='javascript:hideAll()'>- collapse all</a> <a href='javascript:showAll()'>+ expand all</a></p>")

print("<table width='100%'>")

for (category, count) in sorted(list(results.category_count.items()), key=lambda x: x[1], reverse=True):

sys.stdout.write("<tr>")

sys.stdout.write("<td class='%s' id='%s'>" % ("category", category.full_name() + "-cat"))

sys.stdout.write("""<a class='twisty' href="javascript:toggle('%s')"><span class='twisty'> &#9662; </span></a>""" % (category.full_name(),))

sys.stdout.write("%s</td><td width='*' align='right'>%s</td></tr>""" % (category.full_name(), count))

print("<tr class='%s' id='%s'>" % ("words", category.full_name()))

print("<td style='padding-left: 1cm;' colspan='2'>")

words = uniq_c(results.category_words[category])

for word in words:

sys.stdout.write("%s<span class='word-count'>%s</span> " % (word))

print("\n</td></tr>")

total_count += count

print("</table>")

# Summary for each top-level category

top_categories = list(self.category_tree.children.values())

def get_top_category(cat):

for top_cat in top_categories:

if cat.isa(top_cat):

return top_cat

print("Category %s doesn't exist in %s" % (category, top_categories))

top_category_counts = {}

for top_category in top_categories:

top_category_counts[top_category] = 0

for category in results.category_count:

top_category = get_top_category(category)

if top_category:

top_category_counts[top_category] += results.category_count[category]

def percent(x, y):

if y == 0:

return 0

else:

return (100.0 * x) / y

print("<table>")

for top_category in top_categories:

count = top_category_counts[top_category]

print("<tr><td>%s:</td><td>%f %%</td></tr>" % (top_category.full_name(), percent(count, total_count)))

print("<table>")

# Word count

print("<p>%d words total</p>" % (results.word_count,))

print("</body></html>")

def ensure_category(self, *args):

def ensure_cat_aux(category, category_path):

if len(category_path) == 0 or category_path[0] == None:

return category

else:

cat = category_path.pop(0)

if not cat in category.children:

category.children[cat] = Category(cat, category)

return ensure_cat_aux(category.children[cat], category_path)

return ensure_cat_aux(self.category_tree, list(args))

class RIDResults:

def __init__(self):

self.category_count = {}

self.category_words = {}

self.word_count = 0

WORD_REGEX = re.compile(r'[^a-zA-Z]+')

def tokenize(string):

tokens = WORD_REGEX.split(string.lower())

tokens = [token for token in tokens if len(token) > 0]

return tokens

def count_leading_tabs(string):

for i, char in enumerate(string):

if char != '\t':

return i

class DiscriminationTree:

"""

This is the discrimination tree we use for mapping words to

categories. The put method is used to insert category nodes in the

tree, associated with some word pattern. The retrieve method finds

the category for a given word, if one exists.

"""

def __init__(self, index, parent):

self.index = index

self.parent = parent

self.leaves = []

self.interiors = []

self.is_wildcard = False

def __str__(self):

return "<DiscriminationTree %s>" % (self.index,)

def child_matching_index(self, index):

for child in self.interiors:

if child.index == index:

return child

return None

def retrieve(self, path):

if len(path) == 0 or self.is_wildcard:

return self.leaves

else:

next_index = path[0]

next_disc_tree = self.child_matching_index(next_index)

if next_disc_tree == None:

return

else:

return next_disc_tree.retrieve(path[1:])

def put(self, path, leaf):

if len(path) == 0:

if isinstance(leaf, DiscriminationTree):

self.interiors.append(leaf)

else:

self.leaves.append(leaf)

return True

else:

next_index = path[0]

if next_index == '*':

# Got a '*' so this is a wildcard node that will match

# anything that reaches it.

self.is_wildcard = True

self.leaves.append(leaf)

else:

next_disc_tree = self.child_matching_index(next_index)

if next_disc_tree == None:

next_disc_tree = DiscriminationTree(next_index, self)

self.interiors.append(next_disc_tree)

next_disc_tree.put(path[1:], leaf)

def dump(self, stream=sys.stdout, indent=0):

stream.write("\n" + " "*indent + str(self))

for child in self.leaves:

stream.write("\n" + " "*(indent + 3) + str(child))

for child in self.interiors:

child.dump(stream=stream, indent=indent + 3)

class Category:

def __init__(self, name, parent):

self.name = name

self.parent = parent

self.children = {}

self.leaves = []

def __str__(self):

return "<Category %s>" % (self.full_name(),)

def add_word_pattern(self, pattern):

self.leaves.append(pattern)

def full_name(self):

if self.parent == None or isinstance(self.parent, CategoryRoot):

return self.name

else:

return self.parent.full_name() + ":" + self.name

def isa(self, parent):

return parent == self or (self.parent and self.parent.isa(parent))

class CategoryRoot(Category):

def __init__(self):

Category.__init__(self, 'root', None)

def full_name(self):

return ""

def uniq_c(words):

words.sort()

results = []

last_word = words[0]

last_word_count = 1

for word in words[1:]:

if word == last_word:

last_word_count += 1

else:

results.append((last_word, last_word_count))

last_word = word

last_word_count = 1

results.append((last_word, last_word_count))

results = sorted(results, key=lambda x: x[1], reverse=True)

return results

# This dictionary is the one from

# http://www.provalisresearch.com/Download/RID.ZIP with misspellings

# fixed.

DEFAULT_RID_DICTIONARY = """

PRIMARY

NEED

ORALITY

ABSINTH* (1)

ALE (1)

ALES (1)

ALIMENTARY (1)

AMBROSIA* (1)

AMBROSIAL* (1)

APPETIT* (1)

APPLE* (1)

ARTICHOK* (1)

ASPARAGU* (1)

BACON* (1)

BANANA* (1)

BEAN* (1)

BEEF* (1)

BEER* (1)

BELCH* (1)

BELLIES (1)

BELLY (1)

BERRI* (1)

BERRY* (1)

BEVERAG* (1)

BISCUIT* (1)

BITE* (1)

BITE (1)

BITES (1)

BITING (1)

BITTEN* (1)

BONBON* (1)

BRANDY* (1)

BREAD* (1)

BREAKFAST* (1)

BREAST* (1)

BREW* (1)

BROTH (1)

BURP* (1)

BUTTER* (1)

BUTTERMILK* (1)

CAFE (1)

CAFES (1)

CAKE (1)

CAKES (1)

CAFETARIA (1)

CANDY* (1)

CANNIBAL* (1)

CAVIAR* (1)

CHAMPAGN* (1)

CHEES* (1)

CHERRI* (1)

CHERRY* (1)

CHESTNUT* (1)

CHEW* (1)

CHOK* (1)

CIDER* (1)

CLARET* (1)

COB (1)

COBS (1)

COCOA* (1)

COCOANUT* (1)

COCONUT* (1)

COFFE* (1)

CONSUM* (1)

COOK* (1)

CORN* (1)

COUGH* (1)

CRANBERRY* (1)

CREAM* (1)

DELICACI* (1)

DELICACY* (1)

DESSERT* (1)

DEVOUR* (1)

DIET* (1)

DIGEST* (1)

DINE (1)

DINES (1)

DINING (1)

DINNER* (1)

DISH (1)

DISHES (1)

DRANK* (1)

DRINK* (1)

DRUNK* (1)

DRUNKEN* (1)

EAT* (1)

EATEN* (1)

EGG* (1)

ENTRAIL* (1)

FAMIN* (1)

FAMISH* (1)

FAST (1)

FASTS (1)

FAT (1)

FATTEN* (1)

FEAST* (1)

FED (1)

FEED (1)

FEEDS (1)

FIG (1)

FIGS (1)

FLOUR* (1)

FOOD* (1)

FOODSTUFF* (1)

FORK* (1)

FRUIT* (1)

GARLIC* (1)

GIN (1)

GINGER* (1)

GINS (1)

GLUTTON* (1)

GLUTTONOU* (1)

GNAW* (1)

GOBBL* (1)

GRAIN* (1)

GRAP* (1)

GROG* (1)

GRUEL* (1)

GULP* (1)

GUM (1)

GUMS (1)

GUT (1)

GUTS (1)

HAM (1)

HAMS (1)

HERB* (1)

HONEY* (1)

HUNGER* (1)

HUNGRY* (1)

IMBIB* (1)

INEDIBL* (1)

INTESTIN* (1)

JAW* (1)

JUIC* (1)

LAP (1)

LAPS (1)

LEMON* (1)

LICK* (1)

LIME (1)

LIMES (1)

LIP (1)

LIPS (1)

LIQUEUR* (1)

LIQUOR* (1)

LUNCH* (1)

MAIZ* (1)

MEAL* (1)

MEAT* (1)

MELON* (1)

MENU* (1)

MILK* (1)

MINT* (1)

MORSEL* (1)

MOUTH* (1)

MOUTHFUL* (1)

MUSHROOM* (1)

MUTTON* (1)

NAUS* (1)

NECTAR* (1)

NIBBL* (1)

NOURISH* (1)

NOURISHMENT* (1)

NURTUR* (1)

NUT (1)

NUTS (1)

OLIV* (1)

ORAL* (1)

PALAT* (1)

PARTAK* (1)

PASTRI* (1)

PASTRY* (1)

PEA (1)

PEANUT* (1)

PEAR* (1)

PEAS (1)

PEPPER* (1)

PHILTR* (1)

PINEAPPL* (1)

POISON* (1)

PORK* (1)

PORRIDG* (1)

POT (1)

POTATO* (1)

POTBEL* (1)

POTS (1)

PUCKER* (1)

PUMPKIN* (1)

QUENCH* (1)

RASPBERRY* (1)

RAW (1)

RAWLY (1)

REPAST* (1)

RESTAURANT* (1)

RESTAURENT* (1)

RICE (1)

RICES (1)

RIPENES* (1)

ROAST* (1)

RUM (1)

RUMS (1)

SALAD* (1)

SALIVA* (1)

SALIVAT* (1)

SALT* (1)

SAUC* (1)

SAUERKRAUT* (1)

SESAM* (1)

SHERBERT* (1)

SHERRY* (1)

SOUP* (1)

SPAT* (1)

SPIT* (1)

SPITTL* (1)

SPOON* (1)

STARV* (1)

STARVAT* (1)

STOMACH* (1)

STRAWBERRI* (1)

STRAWBERRY* (1)

SUCK* (1)

SUCKL* (1)

SUGAR* (1)

SUPPER* (1)

SWALLOW* (1)

TEA (1)

TEAS (1)

TEAT* (1)

TEETH* (1)

THIRST* (1)

THIRSTY* (1)

THROAT* (1)

TIT (1)

TITS (1)

TOMATO* (1)

TONGU* (1)

TOOTH* (1)

UNCOOK* (1)

VEAL* (1)

VEGETABL* (1)

VENISON* (1)

VODKA* (1)

VOMIT* (1)

WHEAT* (1)

WHISKEY* (1)

WHISKY* (1)

YAM (1)

YAMS* (1)

YEAST* (1)

ANALITY

ANAL (1)

ANUS (1)

ANUSES (1)

ARSE (1)

ARSEHOL* (1)

ASSES (1)

ASS-HOL* (1)

ASSHOL* (1)

BESHAT* (1)

BESHIT* (1)

BESMEAR* (1)

BILE* (1)

BOWEL* (1)

BUTTOCK* (1)

CACK* (1)

CESSPOOL* (1)

CLOACA* (1)

CLOT (1)

CLOTS* (1)

CONSTIPAT* (1)

DANK* (1)

DAUB* (1)

DEFECAT* (1)

DEFIL* (1)

DELOUS* (1)

DIARRHOEA* (1)

DIRT* (1)

DIRTY* (1)

DISGUST* (1)

DUNG* (1)

DUNGHILL* (1)

EFFLUVIA* (1)

EFFLUVIUM* (1)

ENEMA* (1)

EXCRET* (1)

FART (1)

FARTS (1)

FECAL* (1)

FECES (1)

FETID* (1)

FETOR* (1)

FILTH* (1)

FILTHY* (1)

IMPUR* (1)

LATRIN* (1)

LICE (1)

LOATHSOM* (1)

LOUS* (1)

MAGGOT* (1)

MAGGOTY* (1)

MALODOROU* (1)

MALODOUROU* (1)

MANUR* (1)

MESS (1)

MESSES (1)

MESSING (1)

MIASMA* (1)

MUD (1)

MUDDY* (1)

MUDS (1)

OFFAL* (1)

OOZ* (1)

OOZY* (1)

OUTHOUS* (1)

PISS* (1)

POLLUT* (1)

PUTRESCENC* (1)

PUTRESCENT* (1)

PUTRID* (1)

RANCID* (1)

RECTUM* (1)

REEK* (1)

ROT (1)

ROTS (1)

ROTTEN* (1)

ROTTING (1)

RUMP* (1)

SCUM* (1)

SEWER* (1)

SHAT* (1)

SHIT* (1)

SLIMY* (1)

SMEAR* (1)

SODOMIST* (1)

SODOMY* (1)

SOIL* (1)

STAL* (1)

STENCH* (1)

STINK* (1)

SWEAT* (1)

UNCLEAN* (1)

UNWASH* (1)

URIN* (1)

SEX

VENEREAL* (1)

ADULTERER* (1)

ADULTERY* (1)

ALLUR* (1)

BAWD* (1)

BAWDY* (1)

BITCH* (1)

BROTHEL* (1)

CARESS* (1)

CARNAL* (1)

CIRCUMCIS* (1)

CLITORI* (1)

COHABIT* (1)

COITU* (1)

CONCUBIN* (1)

COPULAT* (1)

COQUETT* (1)

COQUETTISH* (1)

COURTESAN* (1)

CUCKOLD* (1)

CUNT* (1)

CUPID* (1)

DEBAUCH* (1)

DEFLOWER* (1)

EJACULAT* (1)

EROTIC* (1)

FONDL* (1)

FORNICAT* (1)

FUCK* (1)

GENITAL* (1)

GENITALIA* (1)

GIRDL* (1)

GROIN* (1)

HAREM* (1)

HARLOT* (1)

HOMOSEXUAL* (1)

HOMOSEXUALITY* (1)

IMMODEST* (1)

INCEST* (1)

INCESTUOU* (1)

INDECENT* (1)

INDISCRET* (1)

INFATUAT* (1)

KISS* (1)

LASCIVIOU* (1)

LECHER* (1)

LECHEROU* (1)

LECHERY* (1)

LEER (1)

LEERS (1)

LEWD* (1)

LIBERTIN* (1)

LICENTIOU* (1)

LOVER* (1)

LUST* (1)

LUSTFUL* (1)

LUSTY* (1)

MASTURBAT* (1)

MENSTRUAL* (1)

MENSTRUAT* (1)

MISTRES* (1)

NAKED (1)

NUDE (1)

NUDES (1)

OBSCEN* (1)

OBSCENITY* (1)

ORGASM* (1)

ORGI* (1)

ORGY* (1)

PANDER* (1)

PARAMOUR* (1)

PENI* (1)

PERVERS* (1)

PERVERT* (1)

PHALLIC* (1)

PHALLU* (1)

PREGNANCY* (1)

PREGNANT* (1)

PROCREAT* (1)

PROSTITUT* (1)

PRURIENT* (1)

PUBERTY* (1)

PUBI* (1)

PUBIC* (1)

RAPE* (1)

RAPING* (1)

RIBALD* (1)

SATYR* (1)

SEDUC* (1)

SENSUAL* (1)

SENSUOU* (1)

SEX (1)

SEXED (1)

SEXES (1)

SEX-LINKED (1)

SEXUAL* (1)

SEXY* (1)

SHAMELES* (1)

SLATTERN* (1)

SLUT* (1)

SLUTTY* (1)

TESTI* (1)

TESTICL* (1)

THIGH* (1)

TROLLOP* (1)

UNBLUSH* (1)

UNDRES* (1)

VAGINA* (1)

VENU* (1)

VOLUPTUOU* (1)

VULVA* (1)

WAIST* (1)

WANTON* (1)

WHOR* (1)

WOMB* (1)

SENSATION (1)

SENSATION

TOUCH

BRUSH* (1)

COARS* (1)

CONTACT* (1)

CUDD* (1)

CUDDL* (1)

HANDL* (1)

ITCH* (1)

ITCHY* (1)

MASSAG* (1)

PRICKL* (1)

ROUGH* (1)

RUB (1)

RUBB* (1)

RUBS (1)

SCALY (1)

SCRATCH* (1)

SHARP* (1)

SLICK* (1)

SLIPPERY* (1)

SMOOTH* (1)

SNUGGL* (1)

STING (1)

STINGS (1)

STROK* (1)

TEXTUR* (1)

THICK* (1)

TICKL* (1)

TINGL* (1)

TOUCH* (1)

WAXY* (1)

TASTE

AFTERTAST* (1)

BITTER* (1)

DELECTABL* (1)

DELICIOU* (1)

FLAVOR* (1)

GALL (1)

HONI* (1)

LUSCIOU* (1)

PIQUANT* (1)

SAVOR* (1)

SAVORY* (1)

SAVOUR* (1)

SAVOURY* (1)

SOUR* (1)

SPIC* (1)

SPICY* (1)

SUGARY* (1)

SWEET* (1)

SWEETNES* (1)

TANG* (1)

TANGY* (1)

TART* (1)

TAST* (1)

TASTY* (1)

TOOTHSOM* (1)

UNPALATABL* (1)

UNSAVORY* (1)

VINEGAR* (1)

VINEGARY* (1)

ODOR

AROMA* (1)

AROMATIC* (1)

BREATH* (1)

COLOGN* (1)

FRAGRANC* (1)

FRAGRANT* (1)

FUME* (1)

FUMING* (1)

INCENS* (1)

INHAL* (1)

MUSK* (1)

MUSKY* (1)

MUSTY* (1)

NOSE* (1)

NOSTRIL* (1)

ODOR* (1)

ODOUR* (1)

PERFUM* (1)

PUNGENC* (1)

PUNGENT* (1)

SCENT* (1)

SMEL* (1)

SMELL* (1)

SNIF* (1)

SNIFF* (1)

GENERAL-SENSATION

APPERCEIVE (1)

APPERCEPTIVE (1)

ATTENT* (1)

AWAR* (1)

AWARENES* (1)

BALMY* (1)

BASK* (1)

BEAUTIFUL* (1)

BEAUTY* (1)

CHARM* (1)