Blame for programs/layer08/08/L08_F08000-08099.py

"""GPT-2 SAE last-token programs, layer 8 -- features 08000 to 08099 (100 programs).

One function per SAE feature. Grouped 100 to a file so the set stays browsable;
the programs themselves are unchanged.
"""

def prog_L08F08000(input_tokens):
    """46 token families, 60 surface forms (train F1 of the uncapped optimum: 0.616).
    Fires at 8,301 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: terminology related to static values and operations in programming or technology"""
    # --- end external annotation ---
    fire = {
        # dynam  (404 firings)
        ' dynamic', ' Dynamic', 'Dynamic',
        # stat  (315 firings)
        ' static', 'static', ' Static', 'Static',
        # defens  (310 firings)
        ' defensive',
        # garbage  (239 firings)
        ' garbage',
        # class  (186 firings)
        ' classical', ' Classical',
        # surplu  (176 firings)
        ' surplus',
        # freel  (174 firings)
        ' freelance',
        # runtime  (142 firings)
        ' runtime', ' Runtime', 'Runtime', 'runtime',
        # stray  (137 firings)
        ' stray',
        # rent  (117 firings)
        ' rental',
        # acoust  (99 firings)
        ' acoustic',
        # rc  (97 firings)
        ' RC', ' rc',
        # ricky  (93 firings)
        ' Ricky',
        # res  (92 firings)
        ' RES', 'RES',
        # fly  (91 firings)
        ' Flyers',
        # repetit  (90 firings)
        ' repetitive',
        # outgo  (89 firings)
        ' outgoing',
        # ambient  (86 firings)
        ' ambient',
        # rapid  (85 firings)
        ' Rapid',
        # overhead  (84 firings)
        ' overhead',
        # newborn  (81 firings)
        ' newborn',
        # gravel  (79 firings)
        ' gravel',
        # offline  (78 firings)
        'Offline',
        # turnov  (75 firings)
        ' turnover',
        # dispos  (73 firings)
        ' disposable',
        # idle  (72 firings)
        ' idle',
        # resp  (65 firings)
        ' resp',
        # reptil  (62 firings)
        ' reptiles',
        # intrins  (56 firings)
        ' intrinsic',
        # spontane  (56 firings)
        ' spontaneous',
        # lifeles  (55 firings)
        ' lifeless',
        # reflex  (53 firings)
        ' reflex', ' Reflex',
        # stationary  (50 firings)
        ' stationary',
        # inco  (46 firings)
        ' inco',
        # ----------------------------------------------------------------  (46 firings)
        '----------------------------------------------------------------',
        # redundant  (46 firings)
        ' redundant',
        # discretionary  (42 firings)
        ' discretionary',
        # rip  (41 firings)
        'RIP', ' RIP',
        # undead  (40 firings)
        ' undead',
        # dynamical  (38 firings)
        ' dynamically',
        # inert  (37 firings)
        ' inert',
        # anarchy  (35 firings)
        ' Anarchy',
        # supplementary  (33 firings)
        ' supplementary', ' Supplementary',
        # ynam  (26 firings)
        'ynamic',
        # airst  (23 firings)
        ' airst',
        # animate  (23 firings)
        'animate',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'dynam-family', 1

def prog_L08F08001(input_tokens):
    """8 token families, 14 surface forms (train F1 of the uncapped optimum: 0.137).
    Fires at 175,135 of 36,786,566 positions.
    Fires at 0.48% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases indicating possession or association"""
    # --- end external annotation ---
    fire = {
        # -  (9,466 firings)
        '-',
        # p  (1,592 firings)
        ' P', 'p', 'P',
        # b  (1,484 firings)
        ' B', 'B', 'b',
        # k  (1,473 firings)
        'k', ' K',
        # 1  (972 firings)
        ' 1',
        # v  (894 firings)
        ' V', 'v',
        # h  (546 firings)
        'h',
        # w  (521 firings)
        'w',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '--family', 1

def prog_L08F08002(input_tokens):
    """38 token families, 50 surface forms (train F1 of the uncapped optimum: 0.423).
    Fires at 20,032 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to JavaScript and its related functionalities"""
    # --- end external annotation ---
    fire = {
        # javascript  (955 firings)
        ' Javascript', ' JavaScript', ' javascript', 'javascript',
        # privacy  (612 firings)
        ' privacy',
        # cbs  (538 firings)
        'CBS',
        # enable  (494 firings)
        ' enable',
        # weekday  (479 firings)
        ' weekday',
        # newslett  (468 firings)
        ' newsletters', 'Newsletter',
        # brows  (441 firings)
        ' browser', 'Browser',
        # what  (263 firings)
        ' Whats',
        # pastebin  (207 firings)
        ' Pastebin',
        # unlock  (204 firings)
        ' unlocks',
        # read  (194 firings)
        ' Reader', 'Reader',
        # regist  (184 firings)
        ' register',
        # tweet  (181 firings)
        ' Tweet',
        # log  (179 firings)
        ' log',
        # html  (163 firings)
        ' HTML',
        # ph  (161 firings)
        'PH',
        # load  (155 firings)
        'Loading', ' Loading',
        # inbox  (149 firings)
        ' inbox',
        # ctv  (136 firings)
        'CTV',
        # ent  (125 firings)
        ' Enter',
        # copyright  (116 firings)
        'Copyright',
        # php  (113 firings)
        'php',
        # merit  (97 firings)
        'Merit',
        # npr  (89 firings)
        'NPR',
        # wik  (86 firings)
        'Wik', ' Wik', 'wik',
        # email  (83 firings)
        'Email',
        # taboola  (79 firings)
        'taboola',
        # google  (73 firings)
        'google', ' google',
        # content  (72 firings)
        'Content', 'content',
        # attribu  (70 firings)
        ' Attribution',
        # untitl  (70 firings)
        'Untitled',
        # iframe  (60 firings)
        'iframe',
        # width  (59 firings)
        ' width',
        # nex  (53 firings)
        ' Nex',
        # transcript  (53 firings)
        ' Transcript',
        # wiki  (53 firings)
        'Wiki',
        # user  (52 firings)
        'User',
        # spoil  (51 firings)
        'Spoiler', ' Spoiler',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'javascript-family', 1

def prog_L08F08003(input_tokens):
    """4 token families, 10 surface forms (train F1 of the uncapped optimum: 0.066).
    Fires at 90,641 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases that express inclusivity and diversity"""
    # --- end external annotation ---
    fire = {
        # or  (3,568 firings)
        ' or', ' Or',
        # no  (1,506 firings)
        ' no', ' No', ' NO',
        # and  (1,007 firings)
        ' And', 'And', ' AND',
        # ;  (573 firings)
        ';', ' ;',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'or-family', 1

def prog_L08F08004(input_tokens):
    """2 token families, 3 surface forms (train F1 of the uncapped optimum: 0.154).
    Fires at 102,124 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to ongoing events or situations in various locations"""
    # --- end external annotation ---
    fire = {
        # in  (46,665 firings)
        ' in', ' IN',
        # inside  (468 firings)
        ' inside',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'in-family', 1

def prog_L08F08005(input_tokens):
    """32 token families, 38 surface forms (train F1 of the uncapped optimum: 0.604).
    Fires at 8,056 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: forms of the prefix "ab," which suggest a theme of separation or negation"""
    # --- end external annotation ---
    fire = {
        # ab  (3,306 firings)
        'ab', ' ab', ' Ab', 'Ab', 'AB', ' AB',
        # reb  (252 firings)
        ' reb',
        # aw  (186 firings)
        ' aw',
        # ur  (180 firings)
        ' ur',
        # ob  (167 firings)
        ' ob',
        # ec  (125 firings)
        ' ec',
        # apost  (121 firings)
        ' apost', ' Apost',
        # unab  (111 firings)
        ' unab',
        # od  (100 firings)
        ' od',
        # unb  (96 firings)
        ' unb',
        # wa  (78 firings)
        ' wa',
        # asc  (76 firings)
        ' asc',
        # wee  (75 firings)
        ' wee',
        # arche  (75 firings)
        ' arche',
        # kab  (73 firings)
        ' Kab',
        # hay  (68 firings)
        ' hay',
        # encro  (57 firings)
        ' encro',
        # receptor  (55 firings)
        ' receptors',
        # forb  (54 firings)
        ' forb',
        # q  (47 firings)
        ' q',
        # dab  (46 firings)
        ' dab',
        # ce  (42 firings)
        ' ce',
        # arg  (37 firings)
        ' arg',
        # ib  (32 firings)
        ' ib',
        # aber  (31 firings)
        ' aber',
        # ah  (31 firings)
        ' ah',
        # ala  (31 firings)
        ' Alas',
        # nob  (30 firings)
        'nob',
        # esche  (29 firings)
        ' esche',
        # alk  (27 firings)
        ' alk',
        # abbre  (25 firings)
        ' abbre',
        # abhor  (21 firings)
        ' abhor',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ab-family', 1

def prog_L08F08006(input_tokens):
    """47 token families, 54 surface forms (train F1 of the uncapped optimum: 0.700).
    Fires at 15,832 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of the name "Albert" and related references to Einstein"""
    # --- end external annotation ---
    fire = {
        # alberta  (765 firings)
        ' Alberta',
        # albert  (575 firings)
        ' Albert', 'Albert',
        # oscar  (541 firings)
        ' Oscar',
        # bert  (534 firings)
        'bert',
        # indian  (345 firings)
        ' Indians',
        # ton  (295 firings)
        'TON',
        # abdullah  (281 firings)
        ' Abdullah',
        # alice  (269 firings)
        ' Alice', 'Alice',
        # aw  (238 firings)
        ' AW', ' aw',
        # dale  (218 firings)
        ' Dale',
        # eagle  (203 firings)
        ' Eagle', ' eagle',
        # einstein  (199 firings)
        ' Einstein',
        # alfr  (197 firings)
        ' Alfred',
        # aby  (193 firings)
        'aby',
        # bowie  (192 firings)
        ' Bowie',
        # moh  (190 firings)
        ' Moh',
        # arlington  (189 firings)
        ' Arlington',
        # ralph  (183 firings)
        ' Ralph',
        # abraham  (141 firings)
        ' Abraham',
        # vet  (137 firings)
        'Veter',
        # irv  (136 firings)
        ' Irving',
        # harold  (132 firings)
        ' Harold',
        # ustra  (126 firings)
        'ustration',
        # ab  (120 firings)
        ' AB',
        # herbert  (117 firings)
        ' Herbert',
        # albion  (111 firings)
        ' Albion',
        # alberto  (108 firings)
        ' Alberto',
        # ر  (107 firings)
        'ر',
        # athletic  (105 firings)
        ' Athletics',
        # alph  (99 firings)
        ' Alph', 'alph',
        # calvin  (94 firings)
        ' Calvin',
        # algeria  (90 firings)
        ' Algeria',
        # annie  (88 firings)
        ' Annie',
        # woody  (82 firings)
        ' Woody',
        # fant  (78 firings)
        ' Fant', ' FANT',
        # ali  (78 firings)
        'Ali', ' ali',
        # ira  (73 firings)
        ' IRA',
        # berto  (71 firings)
        'berto',
        # elvi  (70 firings)
        ' Elvis',
        # urs  (62 firings)
        ' Urs',
        # abbrevi  (62 firings)
        ' abbrevi',
        # idol  (61 firings)
        ' Idol',
        # edmund  (60 firings)
        ' Edmund',
        # mist  (59 firings)
        'mist',
        # mathemat  (57 firings)
        ' mathematic',
        # algebra  (56 firings)
        ' algebra',
        # amer  (51 firings)
        ' americ',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'alberta-family', 1

def prog_L08F08007(input_tokens):
    """9 token families, 22 surface forms (train F1 of the uncapped optimum: 0.154).
    Fires at 353,971 of 36,786,566 positions.
    Fires at 0.96% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: proper nouns and names related to individuals and organizations"""
    # --- end external annotation ---
    fire = {
        # �  (10,491 firings)
        '�',
        # s  (4,611 firings)
        's', 'és', 'ís',
        # (  (3,191 firings)
        ' (',
        # )  (3,051 firings)
        ')',
        # "  (2,470 firings)
        '"',
        # a  (1,327 firings)
        'a', 'ña', 'ía', 'ça',
        # 2  (1,250 firings)
        ' 2', '2',
        # i  (1,181 firings)
        'i',
        # man  (906 firings)
        'man', ' Man', 'Man', 'mans', ' Mans', ' MAN', ' Mansion', ' manic',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '�-family', 1

def prog_L08F08008(input_tokens):
    """28 token families, 66 surface forms (train F1 of the uncapped optimum: 0.493).
    Fires at 139,004 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: nouns related to specific categories or themes, particularly those indicating classifications or identifiers"""
    # --- end external annotation ---
    fire = {
        # police  (3,801 firings)
        'Police', ' Police',
        # form  (2,535 firings)
        'Former', ' Former', 'Form',
        # people  (1,494 firings)
        'People', ' People',
        # media  (1,089 firings)
        'Media',
        # research  (1,084 firings)
        'Researchers', ' Researchers', 'Research',
        # ear  (813 firings)
        'Early', ' Early', 'Ear', 'earable',
        # scientist  (789 firings)
        'Scientists', ' Scientists',
        # no  (684 firings)
        'No',
        # offic  (629 firings)
        'Officers', 'Official', ' Officers', ' Official',
        # much  (603 firings)
        'Much', ' Much',
        # official  (562 firings)
        'Officials', ' Officials',
        # thousand  (557 firings)
        'Thousands', ' Thousands',
        # head  (538 firings)
        'Head', ' Head',
        # high  (500 firings)
        'High', 'Higher', ' Highly',
        # state  (498 firings)
        'State', ' Statements',
        # hundred  (495 firings)
        'Hundreds', ' Hundreds',
        # author  (472 firings)
        'Authorities', ' Authorities', ' Authors',
        # using  (471 firings)
        'Using', ' Using',
        # loc  (464 firings)
        'Local', ' Local',
        # work  (456 firings)
        'Work', 'Working', ' Working',
        # everyth  (454 firings)
        ' Everything', 'Everything',
        # fan  (448 firings)
        'Fans', ' Fans', 'Fan',
        # noth  (432 firings)
        'Nothing', ' Nothing',
        # student  (420 firings)
        'Students', ' Students', 'Student',
        # memb  (418 firings)
        'Members', ' Members', 'Member',
        # recent  (385 firings)
        'Recent', ' Recent',
        # investigator  (361 firings)
        'Investigators', ' Investigators',
        # sourc  (356 firings)
        'Sources', ' Sources',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'police-family', 1

def prog_L08F08009(input_tokens):
    """7 token families, 19 surface forms (train F1 of the uncapped optimum: 0.549).
    Fires at 15,732 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "end" or its variations, indicating conclusions or conclusions of events"""
    # --- end external annotation ---
    fire = {
        # end  (8,524 firings)
        ' end', ' ended', ' ending', ' ends', 'End', ' endings', ' Ending', ' Ends', ' END', ' Ended',
        # conclud  (429 firings)
        ' concluded', ' concludes', ' concluding',
        # finale  (287 firings)
        ' finale',
        # culminat  (152 firings)
        ' culminated', ' culminating',
        # clos  (99 firings)
        ' closes',
        # expir  (93 firings)
        ' expires',
        # terminate  (52 firings)
        ' terminate',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'end-family', 1

def prog_L08F08010(input_tokens):
    """12 token families, 19 surface forms (train F1 of the uncapped optimum: 0.110).
    Fires at 873,616 of 36,786,566 positions.
    Fires at 2.37% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: key terms related to investigations and legal proceedings"""
    # --- end external annotation ---
    fire = {
        # the  (68,431 firings)
        ' the',
        # in  (19,829 firings)
        ' in',
        # thi  (5,862 firings)
        ' this',
        # his  (5,784 firings)
        ' his',
        # he  (4,820 firings)
        ' he', ' HE', 'HE',
        # accord  (3,517 firings)
        ' according', ' Accord',
        # their  (3,347 firings)
        ' their',
        # last  (2,768 firings)
        ' last', ' LAST',
        # there  (2,610 firings)
        ' there', ' THERE',
        # her  (2,550 firings)
        ' her', ' Hers',
        # had  (2,513 firings)
        ' had',
        # just  (2,363 firings)
        ' just', ' JUST',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'the-family', 1

def prog_L08F08011(input_tokens):
    """9 token families, 18 surface forms (train F1 of the uncapped optimum: 0.085).
    Fires at 163,585 of 36,786,566 positions.
    Fires at 0.44% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: sequences of letters and numbers typically associated with identifiers or codes"""
    # --- end external annotation ---
    fire = {
        # :  (2,360 firings)
        ':', ' :',
        # )  (1,456 firings)
        ')', ' )',
        # /  (1,104 firings)
        '/', ' /',
        # $  (641 firings)
        ' $', '$',
        # -  (640 firings)
        ' -',
        # !  (590 firings)
        '!', ' !',
        # pic  (420 firings)
        ' pic', 'pic', ' Pic', 'Pic',
        # |  (417 firings)
        ' |', '|',
        # gmt  (411 firings)
        ' GMT',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ':-family', 1

def prog_L08F08012(input_tokens):
    """48 token families, 51 surface forms (train F1 of the uncapped optimum: 0.668).
    Fires at 12,365 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of prestigious awards, specifically the Nobel and Pulitzer Prizes"""
    # --- end external annotation ---
    fire = {
        # olymp  (949 firings)
        ' Olympic',
        # prize  (525 firings)
        ' Prize',
        # nobel  (464 firings)
        ' Nobel',
        # oscar  (360 firings)
        ' Oscar',
        # billionaire  (261 firings)
        ' billionaire',
        # osama  (220 firings)
        ' Osama',
        # marathon  (218 firings)
        ' Marathon',
        # phd  (200 firings)
        ' PhD',
        # emmy  (169 firings)
        ' Emmy',
        # grammy  (164 firings)
        ' Grammy',
        # lottery  (142 firings)
        ' lottery',
        # nob  (136 firings)
        'nob', 'Nob', ' Nob',
        # noble  (134 firings)
        ' Noble',
        # swat  (133 firings)
        ' SWAT',
        # knox  (128 firings)
        ' Knox',
        # pulitz  (127 firings)
        ' Pulitzer',
        # ted  (124 firings)
        ' TED',
        # pharmaceut  (124 firings)
        ' pharmaceutical',
        # hugo  (123 firings)
        ' Hugo',
        # doctor  (122 firings)
        ' doctoral', 'doctoral',
        # wembley  (120 firings)
        ' Wembley',
        # sharia  (120 firings)
        ' Sharia',
        # europa  (119 firings)
        ' Europa',
        # guin  (115 firings)
        ' Guinness',
        # tur  (104 firings)
        ' Turing',
        # klux  (103 firings)
        ' Klux',
        # heisman  (102 firings)
        ' Heisman',
        # naacp  (99 firings)
        ' NAACP',
        # volkswagen  (97 firings)
        ' Volkswagen',
        # smithsonian  (89 firings)
        ' Smithsonian',
        # parkinson  (86 firings)
        ' Parkinson',
        # oprah  (85 firings)
        ' Oprah',
        # honorary  (85 firings)
        ' honorary',
        # institut  (82 firings)
        ' Institutes',
        # oslo  (81 firings)
        ' Oslo',
        # playboy  (80 firings)
        ' Playboy',
        # lancet  (80 firings)
        ' Lancet',
        # hawk  (79 firings)
        ' Hawking',
        # laureate  (67 firings)
        ' laureate',
        # brook  (63 firings)
        ' Brookings',
        # chomsky  (57 firings)
        ' Chomsky',
        # para  (55 firings)
        ' Paraly',
        # omsday  (53 firings)
        'omsday',
        # kyoto  (52 firings)
        ' Kyoto',
        # macarthur  (50 firings)
        ' MacArthur',
        # laure  (43 firings)
        ' laure',
        # doomsday  (41 firings)
        ' Doomsday',
        # fluorescent  (40 firings)
        ' fluorescent',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'olymp-family', 1

def prog_L08F08013(input_tokens):
    """3 token families, 6 surface forms (train F1 of the uncapped optimum: 0.827).
    Fires at 35,448 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "many" and related quantities"""
    # --- end external annotation ---
    fire = {
        # many  (25,087 firings)
        ' many', ' Many', 'Many', 'many',
        # numer  (686 firings)
        ' numerous',
        # countles  (523 firings)
        ' countless',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'many-family', 1

def prog_L08F08014(input_tokens):
    """19 token families, 45 surface forms (train F1 of the uncapped optimum: 0.212).
    Fires at 199,291 of 36,786,566 positions.
    Fires at 0.54% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the band "The Who" and its associated contexts"""
    # --- end external annotation ---
    fire = {
        # s  (2,287 firings)
        's',
        # trump  (1,491 firings)
        ' Trump', 'Trump', ' trump', 'trump', 'TRUMP',
        # unit  (1,320 firings)
        ' United', 'United', 'Unit', 'united',
        # o  (1,216 firings)
        'o', 'O',
        # company  (1,121 firings)
        ' company', ' Company',
        # getty  (999 firings)
        'Getty', ' Getty',
        # ap  (952 firings)
        ' AP', 'AP',
        # a  (857 firings)
        'a',
        # on  (829 firings)
        'on', 'ON',
        # is  (799 firings)
        'is', 'IS', ' IS',
        # g  (646 firings)
        'G',
        # m  (640 firings)
        'M',
        # may  (631 firings)
        ' May', 'May', ' Mayer',
        # reut  (610 firings)
        'Reuters', ' Reuters', ' REUTERS',
        # time  (572 firings)
        ' Time', ' TIME', 'Time', 'TIME',
        # ia  (565 firings)
        'IA', 'ia',
        # more  (530 firings)
        ' MORE',
        # who  (529 firings)
        ' Who', ' WHO', 'WHO',
        # dead  (499 firings)
        ' Dead', 'Dead', ' DEAD',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 's-family', 1

def prog_L08F08015(input_tokens):
    """20 token families, 22 surface forms (train F1 of the uncapped optimum: 0.339).
    Fires at 25,121 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: characters or symbols from a specific non-Latin alphabet script"""
    # --- end external annotation ---
    fire = {
        # ..........  (528 firings)
        ' ..........',
        # и  (268 firings)
        'и',
        # а  (241 firings)
        'а',
        # н  (218 firings)
        'н',
        # е  (214 firings)
        'е',
        # т  (193 firings)
        'т',
        # р  (143 firings)
        'р',
        # с  (137 firings)
        'с',
        # к  (131 firings)
        'к',
        # о�  (113 firings)
        'о�',
        # о  (112 firings)
        'о',
        # ي  (97 firings)
        'ي',
        # ‎  (95 firings)
        '\u200e',
        # л  (93 firings)
        'л',
        # ن  (90 firings)
        'ن',
        # ال  (79 firings)
        ' ال', 'ال',
        # ا  (70 firings)
        'ا',
        # в  (68 firings)
        'в',
        # م  (67 firings)
        'م', ' م',
        # ς  (65 firings)
        'ς',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '..........-family', 1

def prog_L08F08016(input_tokens):
    """5 token families, 7 surface forms (train F1 of the uncapped optimum: 0.891).
    Fires at 10,333 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: specific dates, particularly in June"""
    # --- end external annotation ---
    fire = {
        # june  (7,314 firings)
        ' June', 'June',
        # jun  (778 firings)
        ' Jun', 'Jun',
        # pdt  (127 firings)
        ' PDT',
        # une  (69 firings)
        'UNE',
        # ileen  (46 firings)
        'ileen',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'june-family', 1

def prog_L08F08017(input_tokens):
    """3 token families, 4 surface forms (train F1 of the uncapped optimum: 0.042).
    Fires at 38,219 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases that indicate positions or states of being at the forefront of situations or issues"""
    # --- end external annotation ---
    fire = {
        # the  (21,517 firings)
        ' the', ' THE',
        # same  (480 firings)
        ' same',
        # top  (227 firings)
        ' top',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'the-family', 1

def prog_L08F08018(input_tokens):
    """12 token families, 15 surface forms (train F1 of the uncapped optimum: 0.089).
    Fires at 551,255 of 36,786,566 positions.
    Fires at 1.50% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to decision-making processes within organizations"""
    # --- end external annotation ---
    fire = {
        # the  (34,216 firings)
        ' the',
        # that  (6,481 firings)
        ' that',
        # from  (4,234 firings)
        ' from',
        # as  (3,759 firings)
        ' as',
        # be  (3,506 firings)
        ' be',
        # year  (3,392 firings)
        ' year', ' years', 'year', ' yearly',
        # his  (2,690 firings)
        ' his',
        # been  (2,345 firings)
        ' been',
        # its  (1,692 firings)
        ' its',
        # people  (1,616 firings)
        ' people',
        # when  (1,493 firings)
        ' when',
        # some  (1,468 firings)
        ' some',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'the-family', 1

def prog_L08F08019(input_tokens):
    """8 token families, 12 surface forms (train F1 of the uncapped optimum: 0.125).
    Fires at 91,263 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: punctuation or special characters that signal the end of statements"""
    # --- end external annotation ---
    fire = {
        # ,"  (3,970 firings)
        ',"', ' ,"',
        # ?  (2,552 firings)
        '?',
        # —  (2,431 firings)
        ' —',
        # by  (1,271 firings)
        'By', ' By',
        # ."  (1,221 firings)
        '."', ' ."',
        # pic  (466 firings)
        ' pic', 'pic',
        # mr  (399 firings)
        ' Mr',
        # ",  (337 firings)
        '",',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ',"-family', 1

def prog_L08F08020(input_tokens):
    """7 token families, 10 surface forms (train F1 of the uncapped optimum: 0.147).
    Fires at 207,003 of 36,786,566 positions.
    Fires at 0.56% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to specific events or entities in popular culture"""
    # --- end external annotation ---
    fire = {
        # )  (2,300 firings)
        ')',
        # ?  (1,302 firings)
        '?', ' ?',
        # !  (968 firings)
        '!', ' !',
        # 2017  (909 firings)
        ' 2017', '2017',
        # '  (676 firings)
        "'",
        # 2  (654 firings)
        ' 2',
        # 1  (642 firings)
        ' 1',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ')-family', 1

def prog_L08F08021(input_tokens):
    """12 token families, 22 surface forms (train F1 of the uncapped optimum: 0.522).
    Fires at 19,928 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to significant events and their details"""
    # --- end external annotation ---
    fire = {
        # event  (6,749 firings)
        ' events', ' event', ' Events', ' Event', 'event', 'Events', 'events', ' EVENTS',
        # happen  (558 firings)
        ' happening',
        # develop  (402 firings)
        ' developments',
        # unfold  (376 firings)
        ' unfolded', ' unfold', ' unfolding', ' unfolds',
        # tragedy  (362 firings)
        ' tragedy',
        # circumstanc  (297 firings)
        ' circumstances',
        # proceed  (267 firings)
        ' proceedings',
        # incident  (258 firings)
        ' incidents',
        # phenomena  (136 firings)
        ' phenomena',
        # trauma  (72 firings)
        ' trauma',
        # disast  (68 firings)
        ' disasters',
        # traged  (65 firings)
        ' tragedies',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'event-family', 1

def prog_L08F08022(input_tokens):
    """30 token families, 59 surface forms (train F1 of the uncapped optimum: 0.330).
    Fires at 29,754 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: actions related to reversing or undoing policies"""
    # --- end external annotation ---
    fire = {
        # change  (676 firings)
        ' change',
        # halt  (547 firings)
        ' halt', ' halted', ' halting',
        # revers  (483 firings)
        ' reversed', ' reversal', ' reversing', ' reversible',
        # overturn  (459 firings)
        ' overturn', ' overturned',
        # reverse  (427 firings)
        ' reverse', 'reverse', ' Reverse',
        # correct  (380 firings)
        ' correct', ' corrected', ' correcting', ' corrective', 'correct',
        # shift  (285 firings)
        ' shift', ' shifts',
        # repeat  (201 firings)
        ' repeat', ' repeating', ' repeats', ' Repeat', 'Repeat',
        # stripp  (189 firings)
        ' stripped', ' stripping',
        # correc  (164 firings)
        'Correction', ' correction', ' Correction',
        # accelerat  (164 firings)
        ' accelerated', ' accelerating',
        # restor  (147 firings)
        ' restored', ' restoring', ' restores',
        # alt  (142 firings)
        ' alter',
        # undo  (127 firings)
        ' undo',
        # alter  (125 firings)
        ' altering', ' altered',
        # reconsid  (123 firings)
        ' reconsider',
        # revok  (122 firings)
        ' revoked',
        # accelerate  (116 firings)
        ' accelerate',
        # turnaround  (108 firings)
        ' turnaround',
        # retract  (104 firings)
        ' retracted', ' retract',
        # rescind  (103 firings)
        ' rescind',
        # cancel  (103 firings)
        ' cancel',
        # flipp  (101 firings)
        ' flipped',
        # repeal  (94 firings)
        ' repealed', ' repealing',
        # affirm  (89 firings)
        ' affirmed', ' affirm',
        # reset  (85 firings)
        ' reset',
        # revert  (85 firings)
        ' revert', ' reverted',
        # erase  (82 firings)
        ' erase',
        # turn  (79 firings)
        'turn',
        # offset  (78 firings)
        ' offset', ' offsets',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'change-family', 1

def prog_L08F08023(input_tokens):
    """2 token families, 2 surface forms (train F1 of the uncapped optimum: 0.156).
    Fires at 167,101 of 36,786,566 positions.
    Fires at 0.45% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: sentences that express uncertainty or raise questions"""
    # --- end external annotation ---
    fire = {
        # .  (97,093 firings)
        '.',
        # ?  (7,715 firings)
        '?',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '.-family', 1

def prog_L08F08024(input_tokens):
    """20 token families, 45 surface forms (train F1 of the uncapped optimum: 0.095).
    Fires at 541,152 of 36,786,566 positions.
    Fires at 1.47% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: official titles or entities within a given context"""
    # --- end external annotation ---
    fire = {
        # ,  (40,329 firings)
        ',',
        # a  (24,402 firings)
        ' a', ' A',
        # that  (11,698 firings)
        ' that',
        # the  (10,814 firings)
        ' The', 'The',
        # but  (6,422 firings)
        ' but', ' But', 'But',
        # i  (4,700 firings)
        ' I',
        # who  (3,580 firings)
        ' who', 'who', 'Who',
        # and  (3,323 firings)
        ' And', 'and', 'And', 'anding', 'anders',
        # which  (3,259 firings)
        ' which', 'which', ' Which', 'Which',
        # ?  (3,251 firings)
        '?',
        # new  (2,704 firings)
        ' new', ' newer',
        # about  (2,673 firings)
        ' about',
        # there  (2,621 firings)
        ' there', ' There',
        # thi  (2,080 firings)
        ' This', 'This',
        # people  (2,072 firings)
        ' people', ' People', 'People',
        # like  (1,893 firings)
        ' like', 'like',
        # my  (1,831 firings)
        ' my', ' My', 'My',
        # because  (1,639 firings)
        ' because', ' Because', 'Because', 'because',
        # if  (1,506 firings)
        'If', ' If',
        # it  (1,467 firings)
        ' It',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ',-family', 1

def prog_L08F08025(input_tokens):
    """45 token families, 51 surface forms (train F1 of the uncapped optimum: 0.692).
    Fires at 10,299 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the name "Baba." """
    # --- end external annotation ---
    fire = {
        # bab  (766 firings)
        ' Bab', ' babies', ' bab',
        # madd  (232 firings)
        ' Madd',
        # hos  (228 firings)
        ' Hos',
        # bah  (226 firings)
        ' Bah', 'Bah',
        # gab  (225 firings)
        ' Gab', 'Gab',
        # barn  (174 firings)
        ' Barn',
        # man  (171 firings)
        ' Mans',
        # rab  (170 firings)
        ' Rab', ' rab',
        # abram  (147 firings)
        ' Abrams',
        # wax  (146 firings)
        ' wax',
        # mum  (132 firings)
        ' mum', ' Mum',
        # mam  (131 firings)
        ' Mam',
        # buzz  (131 firings)
        ' Buzz',
        # incub  (124 firings)
        ' incub',
        # reb  (114 firings)
        'Reb',
        # hod  (107 firings)
        ' Hod',
        # hom  (103 firings)
        ' Homs',
        # infant  (102 firings)
        ' infants',
        # bod  (101 firings)
        ' Bod',
        # kab  (99 firings)
        ' Kab',
        # kad  (98 firings)
        ' Kad',
        # pediatr  (96 firings)
        ' pediatric',
        # pedd  (91 firings)
        ' pedd',
        # dram  (88 firings)
        ' dram',
        # nab  (87 firings)
        ' Nab',
        # theat  (86 firings)
        ' theat',
        # lad  (82 firings)
        ' lad',
        # cyru  (81 firings)
        ' Cyrus',
        # preschool  (78 firings)
        ' preschool',
        # dup  (75 firings)
        ' dup',
        # nursery  (73 firings)
        ' nursery',
        # babylon  (70 firings)
        ' Babylon',
        # boll  (69 firings)
        ' Boll',
        # gob  (69 firings)
        ' gob',
        # tut  (67 firings)
        ' Tut',
        # condition  (67 firings)
        ' conditional',
        # glimp  (64 firings)
        ' glimps',
        # drib  (60 firings)
        ' drib',
        # dispen  (59 firings)
        ' dispens',
        # lull  (56 firings)
        ' lull',
        # pix  (55 firings)
        ' Pix',
        # bas  (51 firings)
        ' BAS',
        # dab  (49 firings)
        ' dab',
        # dazz  (47 firings)
        ' dazz',
        # dwind  (45 firings)
        ' dwind',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'bab-family', 1

def prog_L08F08026(input_tokens):
    """13 token families, 16 surface forms (train F1 of the uncapped optimum: 0.051).
    Fires at 123,689 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to authority figures and their actions or characteristics"""
    # --- end external annotation ---
    fire = {
        # who  (2,620 firings)
        ' who', 'who',
        # have  (2,544 firings)
        ' have',
        # they  (1,618 firings)
        ' they',
        # we  (1,439 firings)
        ' we',
        # some  (1,136 firings)
        ' some',
        # how  (856 firings)
        ' how',
        # there  (825 firings)
        ' there', ' THERE',
        # make  (627 firings)
        ' make',
        # because  (523 firings)
        ' because',
        # any  (510 firings)
        ' any',
        # those  (442 firings)
        ' those',
        # why  (314 firings)
        ' why', ' Why',
        # oth  (310 firings)
        ' others',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'who-family', 1

def prog_L08F08027(input_tokens):
    """2 token families, 3 surface forms (train F1 of the uncapped optimum: 0.087).
    Fires at 69,654 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "email" in various contexts"""
    # --- end external annotation ---
    fire = {
        # ,  (58,239 firings)
        ',', ' ,',
        # ,"  (2,473 firings)
        ',"',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ',-family', 1

def prog_L08F08028(input_tokens):
    """17 token families, 38 surface forms (train F1 of the uncapped optimum: 0.092).
    Fires at 481,028 of 36,786,566 positions.
    Fires at 1.31% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: incidents of violence or severe crime"""
    # --- end external annotation ---
    fire = {
        # a  (17,457 firings)
        ' a',
        # is  (10,364 firings)
        ' is', ' Is',
        # it  (10,023 firings)
        ' it', ' It',
        # i  (6,782 firings)
        ' I', ' i',
        # but  (6,323 firings)
        ' but', ' But',
        # the  (5,421 firings)
        ' The',
        # you  (4,965 firings)
        ' you', ' You', 'you',
        # we  (3,602 firings)
        ' we', ' We',
        # one  (3,306 firings)
        ' one', ' One',
        # thi  (2,172 firings)
        ' This',
        # some  (2,112 firings)
        ' some', ' Some',
        # say  (2,086 firings)
        ' says', ' say', ' saying', ' Says', ' Saying',
        # there  (1,779 firings)
        ' there', ' There', ' THERE',
        # subscribe  (1,684 firings)
        ' Subscribe', 'Subscribe',
        # m  (1,329 firings)
        'm', "'m",
        # see  (1,325 firings)
        ' see', 'see', ' Seeing',
        # that  (1,258 firings)
        ' That', 'That', ' thats',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'a-family', 1

def prog_L08F08029(input_tokens):
    """7 token families, 12 surface forms (train F1 of the uncapped optimum: 0.096).
    Fires at 202,961 of 36,786,566 positions.
    Fires at 0.55% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: keywords associated with operations or initiatives, particularly those labeled with specific names or codes"""
    # --- end external annotation ---
    fire = {
        # :  (4,159 firings)
        ':', ' :',
        # !  (986 firings)
        '!', ' !',
        # against  (757 firings)
        ' against', ' Against',
        # [  (711 firings)
        ' [',
        # 11  (671 firings)
        '11',
        # ]  (651 firings)
        ']', ' ]',
        # between  (512 firings)
        ' between', ' Between',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ':-family', 1

def prog_L08F08030(input_tokens):
    """28 token families, 51 surface forms (train F1 of the uncapped optimum: 0.305).
    Fires at 49,450 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to causes of incidents or issues"""
    # --- end external annotation ---
    fire = {
        # reason  (2,141 firings)
        ' reason', ' reasons', ' reasoning', 'Reason',
        # respons  (1,193 firings)
        ' responsible', ' responsibility',
        # cause  (1,101 firings)
        ' cause', ' Cause', 'cause', 'Cause',
        # source  (935 firings)
        ' source',
        # origin  (704 firings)
        ' origin', ' origins', 'Original', 'Origin', ' Origins',
        # involv  (524 firings)
        ' involved',
        # caus  (512 firings)
        ' causes', ' causal', ' Causes',
        # victim  (469 firings)
        ' victims',
        # factor  (382 firings)
        ' factors', ' factor', ' Factors',
        # explana  (378 firings)
        ' explanation',
        # ident  (340 firings)
        ' identity', ' identities',
        # mot  (277 firings)
        ' motive', ' motives',
        # blame  (259 firings)
        ' blame',
        # purpose  (257 firings)
        ' purpose',
        # root  (256 firings)
        ' root', ' roots',
        # perpetrator  (231 firings)
        ' perpetrators', ' perpetrator',
        # mechanism  (224 firings)
        ' mechanisms', ' mechanism',
        # circumstanc  (193 firings)
        ' circumstances',
        # cure  (181 firings)
        ' cure',
        # culprit  (179 firings)
        ' culprit',
        # winn  (179 firings)
        ' winners', ' Winners',
        # inspira  (176 firings)
        ' inspiration',
        # kill  (167 firings)
        ' killer', ' killers',
        # tim  (160 firings)
        ' timing',
        # underly  (146 firings)
        ' underlying',
        # symptom  (146 firings)
        ' symptoms', ' Symptoms',
        # involve  (144 firings)
        ' involvement',
        # motiva  (141 firings)
        ' motivation',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'reason-family', 1

def prog_L08F08031(input_tokens):
    """44 token families, 58 surface forms (train F1 of the uncapped optimum: 0.540).
    Fires at 41,309 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: words related to upholstery or fabric"""
    # --- end external annotation ---
    fire = {
        # ol  (553 firings)
        'OL',
        # lo  (437 firings)
        'lo', 'LO',
        # hol  (420 firings)
        'hol', ' hol', ' HOL', 'Hol',
        # og  (325 firings)
        'OG',
        # angel  (317 firings)
        ' ANGEL',
        # col  (306 firings)
        'COL', 'col', ' COL',
        # ament  (290 firings)
        'ament', 'aments', 'amental',
        # holocaust  (274 firings)
        ' Holocaust',
        # bur  (273 firings)
        'BUR',
        # feld  (255 firings)
        'feld',
        # rah  (202 firings)
        'rah',
        # sidelin  (194 firings)
        ' sidelines',
        # olog  (193 firings)
        'olog', 'OLOG',
        # ital  (185 firings)
        'ital',
        # è  (182 firings)
        'è',
        # bach  (172 firings)
        'bach',
        # cycl  (170 firings)
        'cycl', 'cycles',
        # outlaw  (167 firings)
        ' outlaw',
        # oga  (165 firings)
        'oga',
        # oria  (158 firings)
        'oria',
        # bra  (152 firings)
        'bra',
        # fil  (152 firings)
        'fil', ' FIL', 'FIL',
        # geneva  (149 firings)
        ' Geneva',
        # review  (149 firings)
        ' Reviews', 'Reviewer',
        # hoffman  (148 firings)
        ' Hoffman',
        # hole  (146 firings)
        'hole', ' Hole',
        # frankfurt  (145 firings)
        ' Frankfurt',
        # park  (143 firings)
        ' PARK',
        # ollah  (137 firings)
        'ollah',
        # guantanamo  (136 firings)
        ' Guantanamo',
        # theft  (135 firings)
        ' Theft',
        # wind  (134 firings)
        ' winding',
        # wich  (133 firings)
        'wich',
        # hau  (130 firings)
        'haus',
        # brom  (125 firings)
        ' Brom',
        # ov  (121 firings)
        'OV',
        # ô  (120 firings)
        'ô',
        # oland  (120 firings)
        'oland',
        # duc  (118 firings)
        ' Duc',
        # rab  (115 firings)
        'rab',
        # ual  (112 firings)
        'UAL',
        # iba  (112 firings)
        'iba',
        # olf  (112 firings)
        'olf',
        # othe  (104 firings)
        'othe',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ol-family', 1

def prog_L08F08032(input_tokens):
    """1 token families, 4 surface forms (train F1 of the uncapped optimum: 0.504).
    Fires at 44,532 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: repeated instances of the word "this" in various contexts"""
    # --- end external annotation ---
    fire = {
        # thi  (35,848 firings)
        ' this', 'this', ' THIS', 'THIS',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'thi-family', 1

def prog_L08F08033(input_tokens):
    """30 token families, 67 surface forms (train F1 of the uncapped optimum: 0.264).
    Fires at 89,209 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: verbs related to sales or transactions"""
    # --- end external annotation ---
    fire = {
        # spread  (935 firings)
        ' spread', ' spreading', ' spreads', 'spread',
        # pass  (918 firings)
        ' passed', ' passes',
        # launch  (770 firings)
        ' launched', ' launches', ' launching',
        # sold  (671 firings)
        ' sold',
        # sell  (661 firings)
        ' sell', ' selling', ' sells', ' Selling',
        # air  (631 firings)
        ' aired', ' airing', ' airs',
        # open  (624 firings)
        ' opened', ' opens',
        # continue  (517 firings)
        ' continue', 'continue',
        # work  (514 firings)
        ' works',
        # app  (510 firings)
        ' apply', ' Apply', 'apply',
        # operat  (496 firings)
        ' operating', ' operates', ' operated',
        # count  (487 firings)
        ' count', ' counts', ' counted', ' counting',
        # run  (457 firings)
        ' runs', ' Runs',
        # appl  (437 firings)
        ' applies', ' applied',
        # rank  (435 firings)
        ' ranks', ' ranked', ' rank',
        # carr  (412 firings)
        ' carries', ' carried',
        # fit  (410 firings)
        ' fit', ' fits',
        # pas  (368 firings)
        ' pass',
        # extend  (361 firings)
        ' extend', ' extends', ' extending',
        # weigh  (360 firings)
        ' weighs', ' weighing', ' weigh', ' weighed',
        # tend  (324 firings)
        ' tend', ' tends', ' tended', ' tending',
        # ref  (322 firings)
        ' refers', ' refer',
        # carry  (311 firings)
        ' carry',
        # play  (282 firings)
        ' plays',
        # operate  (281 firings)
        ' operate',
        # dat  (281 firings)
        ' dates', ' dating',
        # debut  (265 firings)
        ' debuted',
        # leak  (250 firings)
        ' leaked', ' leaking',
        # hold  (234 firings)
        ' holds',
        # redirect  (229 firings)
        ' redirect',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'spread-family', 1

def prog_L08F08034(input_tokens):
    """19 token families, 23 surface forms (train F1 of the uncapped optimum: 0.144).
    Fires at 58,216 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: specific URLs and web addresses"""
    # --- end external annotation ---
    fire = {
        # ig  (502 firings)
        'ig',
        # ad  (492 firings)
        'ad',
        # am  (484 firings)
        'am', 'AM',
        # amb  (399 firings)
        'amb',
        # im  (299 firings)
        'im',
        # ah  (258 firings)
        'ah',
        # em  (256 firings)
        'em',
        # ip  (253 firings)
        'ip',
        # ot  (243 firings)
        'ot',
        # ib  (231 firings)
        'ib', 'IB',
        # od  (227 firings)
        'od', 'OD',
        # ok  (226 firings)
        'ok', 'OK',
        # om  (209 firings)
        'om',
        # ag  (195 firings)
        'ag',
        # ap  (188 firings)
        'ap',
        # ow  (184 firings)
        'ow',
        # ob  (181 firings)
        'ob',
        # ep  (162 firings)
        'ep',
        # iv  (161 firings)
        'iv',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ig-family', 1

def prog_L08F08035(input_tokens):
    """11 token families, 13 surface forms (train F1 of the uncapped optimum: 0.557).
    Fires at 9,462 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the letter 'K'"""
    # --- end external annotation ---
    fire = {
        # k  (4,680 firings)
        'k', ' k',
        # kg  (238 firings)
        ' kg', 'kg',
        # ke  (169 firings)
        ' ke',
        # ko  (82 firings)
        ' ko',
        # kosh  (62 firings)
        ' kosher',
        # kh  (46 firings)
        ' kh',
        # kung  (42 firings)
        ' Kung',
        # hk  (33 firings)
        ' HK',
        # kettle  (33 firings)
        ' kettle',
        # dh  (27 firings)
        ' dh',
        # ka  (26 firings)
        ' ka',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'k-family', 1

def prog_L08F08036(input_tokens):
    """19 token families, 24 surface forms (train F1 of the uncapped optimum: 0.086).
    Fires at 160,199 of 36,786,566 positions.
    Fires at 0.44% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of processes related to approval and review"""
    # --- end external annotation ---
    fire = {
        # in  (18,152 firings)
        ' in',
        # at  (5,875 firings)
        ' at',
        # dur  (2,259 firings)
        ' during', 'during',
        # aft  (1,972 firings)
        ' after',
        # when  (1,741 firings)
        ' when',
        # if  (1,299 firings)
        ' if',
        # before  (971 firings)
        ' before',
        # through  (937 firings)
        ' through',
        # until  (804 firings)
        ' until', 'until',
        # using  (788 firings)
        ' using',
        # next  (726 firings)
        ' next',
        # und  (701 firings)
        ' under',
        # via  (677 firings)
        ' via',
        # ago  (641 firings)
        ' ago',
        # lat  (617 firings)
        ' later',
        # 2017  (582 firings)
        ' 2017', '2017',
        # without  (581 firings)
        ' without', 'without',
        # within  (558 firings)
        ' within', 'within',
        # follow  (496 firings)
        ' following',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'in-family', 1

def prog_L08F08037(input_tokens):
    """19 token families, 27 surface forms (train F1 of the uncapped optimum: 0.393).
    Fires at 12,804 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "together" and related phrases emphasizing unity or collaboration"""
    # --- end external annotation ---
    fire = {
        # togeth  (2,248 firings)
        ' together', ' Together', 'Together', 'together',
        # combin  (535 firings)
        ' combined', ' Combined',
        # conjunc  (235 firings)
        ' conjunction',
        # collective  (220 firings)
        ' collectively',
        # confus  (192 firings)
        ' confused',
        # joint  (173 firings)
        ' jointly',
        # soon  (169 firings)
        'Soon', ' Soon',
        # collabora  (148 firings)
        ' collaboration',
        # organ  (124 firings)
        'Organ',
        # iti  (106 firings)
        'iti',
        # coupl  (99 firings)
        ' coupled',
        # apart  (94 firings)
        ' Apart', 'Apart',
        # comb  (86 firings)
        'Comb', ' Comb',
        # unit  (73 firings)
        ' united',
        # independent  (56 firings)
        ' independently',
        # group  (47 firings)
        'Group', ' grouped',
        # friend  (41 firings)
        'Friends',
        # individual  (41 firings)
        ' individually',
        # interconnect  (40 firings)
        ' interconnected',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'togeth-family', 1

def prog_L08F08038(input_tokens):
    """49 token families, 57 surface forms (train F1 of the uncapped optimum: 0.719).
    Fires at 18,242 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of the Jets, a sports team"""
    # --- end external annotation ---
    fire = {
        # jet  (826 firings)
        ' Jets', ' Jet', 'Jet',
        # cub  (438 firings)
        ' Cubs',
        # winnipeg  (403 firings)
        ' Winnipeg',
        # knick  (351 firings)
        ' Knicks',
        # sanchez  (343 firings)
        ' Sanchez',
        # met  (283 firings)
        ' Mets',
        # kushn  (266 firings)
        ' Kushner',
        # nj  (237 firings)
        ' NJ',
        # wis  (222 firings)
        ' Wis',
        # friedman  (221 firings)
        ' Friedman',
        # tsa  (212 firings)
        ' TSA',
        # rutg  (205 firings)
        ' Rutgers',
        # manitoba  (201 firings)
        ' Manitoba',
        # net  (197 firings)
        ' Nets',
        # futur  (188 firings)
        ' futures',
        # pluto  (185 firings)
        ' Pluto',
        # fut  (174 firings)
        ' Fut',
        # trent  (171 firings)
        ' Trent',
        # simpson  (163 firings)
        ' Simpsons',
        # morph  (162 firings)
        ' morph', ' morphed', ' Morph', 'morph',
        # matti  (156 firings)
        ' Mattis',
        # weis  (154 firings)
        ' Weiss', 'Weiss',
        # onz  (141 firings)
        'onz',
        # schwartz  (137 firings)
        ' Schwartz',
        # tur  (132 firings)
        ' Turing',
        # cap  (129 firings)
        ' Caps',
        # bolton  (129 firings)
        ' Bolton',
        # hobbit  (126 firings)
        ' Hobbit',
        # shapiro  (124 firings)
        ' Shapiro',
        # went  (124 firings)
        ' Went',
        # toma  (121 firings)
        ' Tomas',
        # tweak  (120 firings)
        ' tweak', ' tweaked',
        # kirst  (117 firings)
        ' Kirst',
        # middl  (109 firings)
        ' Middles',
        # sik  (106 firings)
        ' Sik',
        # tina  (105 firings)
        ' Tina',
        # pet  (105 firings)
        ' Peters',
        # jit  (95 firings)
        'jit',
        # itect  (92 firings)
        'itect',
        # tick  (92 firings)
        ' ticking', ' Tick',
        # horizon  (90 firings)
        ' Horizons',
        # buc  (82 firings)
        ' Bucs',
        # ket  (81 firings)
        ' ket',
        # enezuel  (78 firings)
        'enezuel',
        # hendrick  (73 firings)
        ' Hendricks',
        # kom  (72 firings)
        ' Kom',
        # neocon  (70 firings)
        ' neocons',
        # fitzpatrick  (64 firings)
        ' Fitzpatrick',
        # wig  (63 firings)
        ' wig',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'jet-family', 1

def prog_L08F08039(input_tokens):
    """14 token families, 16 surface forms (train F1 of the uncapped optimum: 0.753).
    Fires at 14,961 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of a specific agency"""
    # --- end external annotation ---
    fire = {
        # agency  (6,200 firings)
        ' agency', ' Agency', 'agency',
        # agenc  (1,559 firings)
        ' agencies',
        # administra  (884 firings)
        ' Administration',
        # corpora  (324 firings)
        ' Corporation',
        # airline  (278 firings)
        ' airline',
        # contractor  (195 firings)
        ' contractor',
        # aley  (139 firings)
        'aley',
        # bureau  (117 firings)
        ' bureau',
        # directorate  (91 firings)
        ' Directorate',
        # metro  (91 firings)
        'Metro',
        # rag  (72 firings)
        ' rag',
        # gency  (68 firings)
        'gency',
        # enc  (54 firings)
        'encies',
        # bureaucracy  (47 firings)
        ' bureaucracy',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'agency-family', 1

def prog_L08F08040(input_tokens):
    """10 token families, 11 surface forms (train F1 of the uncapped optimum: 0.139).
    Fires at 93,017 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: numerical data related to age ranges and statistics"""
    # --- end external annotation ---
    fire = {
        # th  (2,870 firings)
        'th',
        # year  (2,363 firings)
        'year',
        # percent  (649 firings)
        ' percent',
        # point  (535 firings)
        ' points', 'point',
        # 00  (531 firings)
        '00',
        # block  (445 firings)
        ' block',
        # st  (387 firings)
        'st',
        # minut  (356 firings)
        ' minutes',
        # nd  (327 firings)
        'nd',
        # rd  (317 firings)
        'rd',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'th-family', 1

def prog_L08F08041(input_tokens):
    """35 token families, 46 surface forms (train F1 of the uncapped optimum: 0.574).
    Fires at 12,724 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to various types of pathways or paths"""
    # --- end external annotation ---
    fire = {
        # path  (2,271 firings)
        ' path', ' paths', ' Path', 'path', 'Path', ' PATH', 'pathic', 'PATH',
        # road  (1,071 firings)
        ' road', 'Road',
        # route  (552 firings)
        ' route',
        # pathway  (206 firings)
        ' pathway', ' pathways',
        # progres  (172 firings)
        ' progression',
        # trajectory  (152 firings)
        ' trajectory',
        # avenu  (124 firings)
        ' avenues',
        # hallway  (114 firings)
        ' hallway',
        # propag  (104 firings)
        ' propag',
        # corridor  (104 firings)
        ' Corridor', ' corridor',
        # prot  (89 firings)
        ' prot',
        # footstep  (87 firings)
        ' footsteps',
        # journey  (86 firings)
        ' Journey',
        # labyrinth  (85 firings)
        ' labyrinth', ' Labyrinth',
        # yll  (82 firings)
        'yll',
        # maze  (77 firings)
        ' maze',
        # nem  (75 firings)
        ' nem',
        # psychopath  (71 firings)
        ' psychopath',
        # magnet  (70 firings)
        ' magnet',
        # christina  (67 firings)
        ' Christina',
        # roadmap  (65 firings)
        ' roadmap',
        # avenue  (62 firings)
        ' avenue',
        # nes  (59 firings)
        ' Ness',
        # tal  (54 firings)
        ' Tales',
        # fern  (52 firings)
        ' Fern',
        # doorway  (50 firings)
        ' doorway',
        # pathogen  (48 firings)
        ' pathogens',
        # pathfind  (47 firings)
        ' Pathfinder',
        # lineage  (46 firings)
        ' lineage',
        # morph  (43 firings)
        ' morph',
        # courage  (42 firings)
        ' Courage',
        # opath  (39 firings)
        'opath',
        # herb  (39 firings)
        ' herbal',
        # pathology  (38 firings)
        ' pathology',
        # prism  (32 firings)
        ' prism',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'path-family', 1

def prog_L08F08042(input_tokens):
    """15 token families, 19 surface forms (train F1 of the uncapped optimum: 0.086).
    Fires at 354,368 of 36,786,566 positions.
    Fires at 0.96% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: terms related to communication methods and professional correspondence"""
    # --- end external annotation ---
    fire = {
        # the  (37,798 firings)
        ' the',
        # for  (7,992 firings)
        ' for',
        # with  (5,681 firings)
        ' with',
        # an  (4,828 firings)
        ' an',
        # about  (2,393 firings)
        ' about',
        # first  (1,802 firings)
        ' first',
        # accord  (1,280 firings)
        ' according', ' accordance',
        # what  (1,193 firings)
        ' what',
        # part  (1,029 firings)
        ' part',
        # help  (991 firings)
        ' help', ' helping', ' helpful',
        # how  (991 firings)
        ' how',
        # where  (981 firings)
        ' where',
        # through  (948 firings)
        ' through',
        # way  (946 firings)
        ' way', ' ways',
        # see  (896 firings)
        ' see',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'the-family', 1

def prog_L08F08043(input_tokens):
    """7 token families, 10 surface forms (train F1 of the uncapped optimum: 0.068).
    Fires at 187,920 of 36,786,566 positions.
    Fires at 0.51% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to first experiences or encounters"""
    # --- end external annotation ---
    fire = {
        # in  (16,846 firings)
        ' in',
        # on  (9,158 firings)
        ' on',
        # since  (1,332 firings)
        ' since',
        # against  (1,139 firings)
        ' against',
        # between  (625 firings)
        ' between',
        # see  (531 firings)
        ' see', ' SEE',
        # appear  (509 firings)
        ' appearance', ' appeared', ' Appearance',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'in-family', 1

def prog_L08F08044(input_tokens):
    """4 token families, 7 surface forms (train F1 of the uncapped optimum: 0.090).
    Fires at 130,327 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: monetary pledges and financial commitments"""
    # --- end external annotation ---
    fire = {
        # :  (5,529 firings)
        ':',
        # $  (2,588 firings)
        ' $', '$',
        # ic  (766 firings)
        'ic', 'IC',
        # £  (410 firings)
        ' £', '£',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ':-family', 1

def prog_L08F08045(input_tokens):
    """44 token families, 47 surface forms (train F1 of the uncapped optimum: 0.489).
    Fires at 13,854 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the concept of "momentum" in various contexts"""
    # --- end external annotation ---
    fire = {
        # momentum  (461 firings)
        ' momentum',
        # stall  (252 firings)
        ' stalled', ' stall',
        # senti  (223 firings)
        ' sentiment',
        # pois  (204 firings)
        ' poised',
        # stand  (179 firings)
        ' standings',
        # trac  (161 firings)
        ' traction',
        # trajectory  (149 firings)
        ' trajectory',
        # steam  (142 firings)
        ' steam',
        # fortun  (138 firings)
        ' fortunes',
        # hype  (133 firings)
        ' hype',
        # dynamic  (119 firings)
        ' dynamics',
        # propell  (118 firings)
        ' propelled', ' propell',
        # euph  (117 firings)
        ' euph', ' Euph',
        # ernaut  (104 firings)
        'ernaut',
        # enthusiasm  (99 firings)
        ' enthusiasm',
        # motiva  (95 firings)
        ' motivation',
        # moment  (92 firings)
        ' Moment',
        # suspense  (85 firings)
        ' suspense',
        # buoy  (83 firings)
        ' buoy',
        # ling  (80 firings)
        ' linger',
        # unstopp  (78 firings)
        ' unstoppable',
        # urgency  (75 firings)
        ' urgency',
        # bandwagon  (72 firings)
        ' bandwagon',
        # optimism  (72 firings)
        ' optimism',
        # propel  (68 firings)
        ' propel',
        # sedi  (65 firings)
        ' sediment',
        # surg  (63 firings)
        ' surging',
        # emph  (62 firings)
        ' emph',
        # catalyst  (62 firings)
        ' catalyst',
        # foothold  (61 firings)
        ' foothold',
        # discord  (61 firings)
        ' discord',
        # suitcase  (58 firings)
        ' suitcase',
        # storylin  (58 firings)
        ' storylines',
        # strid  (58 firings)
        ' strides',
        # mindset  (57 firings)
        ' mindset',
        # impetu  (52 firings)
        ' impetus',
        # decisive  (52 firings)
        ' decisively',
        # galvan  (51 firings)
        ' galvan',
        # morale  (51 firings)
        ' morale',
        # heartbeat  (49 firings)
        ' heartbeat',
        # cohe  (45 firings)
        ' cohesion',
        # mongo  (45 firings)
        ' Mongo',
        # snowball  (41 firings)
        ' snowball',
        # hip  (41 firings)
        ' hips',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'momentum-family', 1

def prog_L08F08046(input_tokens):
    """10 token families, 16 surface forms (train F1 of the uncapped optimum: 0.080).
    Fires at 135,436 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: statements expressing opinions or observations about situations"""
    # --- end external annotation ---
    fire = {
        # copyright  (1,861 firings)
        ' copyright',
        # going  (974 firings)
        ' going', 'going',
        # think  (884 firings)
        ' think',
        # very  (859 firings)
        ' very', 'very', 'Very',
        # lot  (658 firings)
        ' lot',
        # real  (654 firings)
        ' really', 'real', 'really',
        # don  (609 firings)
        ' don',
        # thing  (560 firings)
        ' things',
        # alway  (450 firings)
        ' always', 'always',
        # re  (339 firings)
        "'re",
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'copyright-family', 1

def prog_L08F08047(input_tokens):
    """1 token families, 1 surface forms (train F1 of the uncapped optimum: 0.121).
    Fires at 56,765 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases that include the conjunction "and." """
    # --- end external annotation ---
    fire = {
        # and  (38,671 firings)
        ' and',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'and-family', 1

def prog_L08F08048(input_tokens):
    """28 token families, 39 surface forms (train F1 of the uncapped optimum: 0.460).
    Fires at 31,442 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: adverbs, particularly those ending in 'ly'"""
    # --- end external annotation ---
    fire = {
        # ly  (5,162 firings)
        'ly', 'LY',
        # ally  (759 firings)
        'ally', 'ALLY',
        # ably  (641 firings)
        'ably',
        # ate  (403 firings)
        'ately',
        # ical  (388 firings)
        'ically',
        # ily  (325 firings)
        'ily', 'ILY',
        # ful  (284 firings)
        'fully', ' Fully',
        # ent  (268 firings)
        'ently',
        # ial  (234 firings)
        'ially',
        # ive  (201 firings)
        'ively',
        # ear  (183 firings)
        'earing', 'early',
        # ual  (168 firings)
        'ually',
        # body  (161 firings)
        'body',
        # ative  (156 firings)
        'atively',
        # ant  (147 firings)
        'antly',
        # strict  (144 firings)
        ' strictly',
        # mediate  (140 firings)
        'mediate', 'mediately',
        # inal  (139 firings)
        'inally', 'INAL',
        # ential  (138 firings)
        'entially',
        # general  (117 firings)
        'Generally', ' Generally',
        # clear  (111 firings)
        'Clearly', ' Clearly',
        # ari  (104 firings)
        'arily',
        # omew  (102 firings)
        'omew',
        # ere  (94 firings)
        'ERE',
        # most  (90 firings)
        ' Mostly', 'mostly',
        # otal  (88 firings)
        'otally',
        # zen  (82 firings)
        'zens',
        # personal  (79 firings)
        'Personally', ' Personally',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ly-family', 1

def prog_L08F08049(input_tokens):
    """13 token families, 26 surface forms (train F1 of the uncapped optimum: 0.214).
    Fires at 709,419 of 36,786,566 positions.
    Fires at 1.93% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: topics related to immigration and legal issues surrounding it"""
    # --- end external annotation ---
    fire = {
        # ,  (23,760 firings)
        ',',
        # year  (6,775 firings)
        ' year', ' years', 'years',
        # city  (2,680 firings)
        ' city', ' City',
        # trump  (2,673 firings)
        ' Trump',
        # world  (2,551 firings)
        ' world', ' World',
        # state  (2,486 firings)
        ' state', ' State', 'state',
        # people  (2,347 firings)
        ' people',
        # elec  (2,340 firings)
        ' election', 'election', ' Election',
        # "  (2,234 firings)
        '"',
        # country  (2,184 firings)
        ' country',
        # month  (2,167 firings)
        ' month', ' months', ' Month',
        # stat  (2,124 firings)
        ' States', ' states', 'states',
        # season  (2,077 firings)
        ' season', ' seasons',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ',-family', 1

def prog_L08F08050(input_tokens):
    """10 token families, 19 surface forms (train F1 of the uncapped optimum: 0.090).
    Fires at 253,687 of 36,786,566 positions.
    Fires at 0.69% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to tables or structured data within a document"""
    # --- end external annotation ---
    fire = {
        # �  (16,102 firings)
        '�',
        # :  (3,078 firings)
        ':', ' :',
        # )  (1,878 firings)
        ')',
        # b  (799 firings)
        ' B', 'b', ' b',
        # f  (780 firings)
        ' F', 'f', ' f',
        # down  (771 firings)
        ' down', 'down', ' Down', ' DOWN', 'downs',
        # ing  (697 firings)
        'ing',
        # 2  (694 firings)
        ' 2',
        # 1  (667 firings)
        ' 1',
        # 4  (652 firings)
        ' 4',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '�-family', 1

def prog_L08F08051(input_tokens):
    """4 token families, 6 surface forms (train F1 of the uncapped optimum: 0.076).
    Fires at 20,665 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: punctuation marks and dialogue indicators in conversational text"""
    # --- end external annotation ---
    fire = {
        # :  (5,316 firings)
        ':', ' :',
        # >  (227 firings)
        '>', ' >',
        # ):  (92 firings)
        '):',
        # *  (86 firings)
        '*',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return ':-family', 1

def prog_L08F08052(input_tokens):
    """9 token families, 12 surface forms (train F1 of the uncapped optimum: 0.742).
    Fires at 4,473 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions and references to Mac computers"""
    # --- end external annotation ---
    fire = {
        # mac  (2,337 firings)
        ' Mac', 'Mac', ' mac', 'mac',
        # macbook  (209 firings)
        ' MacBook',
        # macron  (195 firings)
        ' Macron',
        # mex  (95 firings)
        'Mex',
        # maco  (70 firings)
        ' macOS',
        # mcmast  (70 firings)
        ' McMaster',
        # macintosh  (61 firings)
        ' Macintosh',
        # oad  (59 firings)
        'oad',
        # mech  (31 firings)
        ' Mech',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'mac-family', 1

def prog_L08F08053(input_tokens):
    """38 token families, 53 surface forms (train F1 of the uncapped optimum: 0.685).
    Fires at 9,851 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: occurrences of the substring "tra" across various contexts"""
    # --- end external annotation ---
    fire = {
        # tra  (1,119 firings)
        ' Tra', 'tra', ' tra', 'Tra', ' TRA',
        # des  (584 firings)
        ' Des',
        # trait  (377 firings)
        ' traits', ' trait',
        # dom  (321 firings)
        ' Dom', 'Dom',
        # trail  (274 firings)
        ' Trail', ' Trails',
        # traff  (239 firings)
        ' Traffic', ' traff', ' Traff',
        # rus  (202 firings)
        ' Russ', 'Russ',
        # tre  (199 firings)
        'Tre', 'tre',
        # derrick  (152 firings)
        ' Derrick',
        # wra  (122 firings)
        ' wra', ' Wra', 'wra', 'Wra',
        # dra  (118 firings)
        ' Dra',
        # pra  (117 firings)
        ' pra', ' Pra',
        # hoffman  (116 firings)
        ' Hoffman',
        # django  (116 firings)
        ' Django',
        # trauma  (104 firings)
        ' trauma',
        # taj  (101 firings)
        ' Taj',
        # sophie  (88 firings)
        ' Sophie',
        # traumat  (85 firings)
        ' traumatic',
        # theo  (84 firings)
        ' Theo',
        # sus  (82 firings)
        'Sus',
        # skywalk  (78 firings)
        ' Skywalker',
        # dri  (73 firings)
        ' Dri',
        # ty  (68 firings)
        'Ty',
        # trav  (63 firings)
        ' travers',
        # russell  (60 firings)
        'Russell',
        # tw  (52 firings)
        'TW',
        # traitor  (51 firings)
        ' traitor',
        # incent  (49 firings)
        'incent',
        # behind  (49 firings)
        'Behind',
        # koen  (47 firings)
        ' Koen',
        # trace  (43 firings)
        ' Trace',
        # traverse  (43 firings)
        ' traverse',
        # omorph  (41 firings)
        'omorph',
        # rudolph  (40 firings)
        ' Rudolph',
        # rosso  (38 firings)
        'rosso',
        # veterinary  (34 firings)
        ' Veterinary',
        # の  (32 firings)
        'の',
        # benef  (28 firings)
        'Benef',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'tra-family', 1

def prog_L08F08054(input_tokens):
    """1 token families, 1 surface forms (train F1 of the uncapped optimum: 0.096).
    Fires at 41,227 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: the phrase "of the" used in various contexts"""
    # --- end external annotation ---
    fire = {
        # of  (36,630 firings)
        ' of',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'of-family', 1

def prog_L08F08055(input_tokens):
    """49 token families, 77 surface forms (train F1 of the uncapped optimum: 0.457).
    Fires at 157,033 of 36,786,566 positions.
    Fires at 0.43% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: titles or roles of notable individuals, particularly those involved in activism or professional achievements"""
    # --- end external annotation ---
    fire = {
        # man  (3,919 firings)
        ' man',
        # candidate  (2,368 firings)
        ' candidate', ' Candidate',
        # ist  (2,191 firings)
        'ist',
        # minist  (2,021 firings)
        ' Minister', ' minister',
        # offic  (2,009 firings)
        ' officer', ' Officer',
        # woman  (1,844 firings)
        ' woman', 'woman',
        # lead  (1,819 firings)
        ' leader', 'leader',
        # star  (1,671 firings)
        ' star',
        # student  (1,617 firings)
        ' student',
        # play  (1,419 firings)
        ' player', ' Player',
        # actor  (1,384 firings)
        ' actor', 'Actor', ' Actor',
        # professor  (1,291 firings)
        ' professor', ' Professor', 'Professor',
        # writ  (1,235 firings)
        ' writer', 'writer',
        # senator  (1,192 firings)
        ' senator', ' Senator',
        # activist  (1,032 firings)
        ' activist',
        # friend  (1,030 firings)
        ' friend', 'friend',
        # artist  (989 firings)
        ' artist', ' Artist', 'artist',
        # journalist  (925 firings)
        ' journalist',
        # champion  (922 firings)
        ' champion', ' Champion',
        # host  (892 firings)
        ' host',
        # own  (851 firings)
        ' owner', 'owner',
        # ceo  (787 firings)
        ' CEO',
        # mp  (779 firings)
        ' MP',
        # report  (748 firings)
        ' reporter',
        # rep  (737 firings)
        ' Rep',
        # midfield  (688 firings)
        ' midfielder',
        # resident  (648 firings)
        ' resident',
        # lawy  (636 firings)
        ' lawyer',
        # teach  (636 firings)
        ' teacher', ' Teacher',
        # quarterback  (631 firings)
        ' quarterback',
        # produc  (608 firings)
        ' producer', ' Producer',
        # mayor  (582 firings)
        ' Mayor',
        # veteran  (565 firings)
        ' veteran', ' Veteran',
        # actres  (564 firings)
        ' actress', ' Actress',
        # ologist  (545 firings)
        'ologist',
        # strik  (544 firings)
        ' striker',
        # scientist  (542 firings)
        ' scientist', ' Scientist',
        # guard  (540 firings)
        ' guard',
        # analyst  (521 firings)
        ' analyst', ' Analyst',
        # advis  (515 firings)
        ' adviser', ' Adviser',
        # defend  (507 firings)
        ' defender',
        # expert  (507 firings)
        ' expert', ' Expert',
        # engine  (490 firings)
        ' engineer', ' Engineer',
        # soldi  (480 firings)
        ' soldier', ' Soldier',
        # legend  (458 firings)
        ' legend', ' legends',
        # politician  (453 firings)
        ' politician',
        # comedian  (446 firings)
        ' comedian',
        # photograph  (419 firings)
        ' photographer',
        # businessman  (401 firings)
        ' businessman',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'man-family', 1

def prog_L08F08056(input_tokens):
    """12 token families, 14 surface forms (train F1 of the uncapped optimum: 0.097).
    Fires at 489,238 of 36,786,566 positions.
    Fires at 1.33% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to events or actions associated with criminal behavior and investigations"""
    # --- end external annotation ---
    fire = {
        # a  (22,726 firings)
        ' a',
        # in  (16,866 firings)
        ' in',
        # by  (6,289 firings)
        ' by',
        # with  (5,888 firings)
        ' with',
        # as  (4,977 firings)
        ' as',
        # from  (4,937 firings)
        ' from',
        # an  (3,765 firings)
        ' an',
        # out  (2,076 firings)
        ' out', 'outed',
        # "  (1,791 firings)
        '"',
        # aft  (1,739 firings)
        ' after',
        # u  (1,344 firings)
        ' U',
        # '  (1,341 firings)
        "'", " '",
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'a-family', 1

def prog_L08F08057(input_tokens):
    """17 token families, 26 surface forms (train F1 of the uncapped optimum: 0.206).
    Fires at 153,200 of 36,786,566 positions.
    Fires at 0.42% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: terms related to organizations, locations, and associated rights and issues"""
    # --- end external annotation ---
    fire = {
        # state  (1,833 firings)
        ' State',
        # univers  (1,251 firings)
        ' University',
        # city  (1,120 firings)
        ' City',
        # county  (1,055 firings)
        ' County',
        # new  (984 firings)
        ' News',
        # today  (937 firings)
        ' TODAY', ' Today',
        # park  (729 firings)
        ' Park', ' Parks', ' Parking',
        # police  (709 firings)
        ' Police',
        # day  (581 firings)
        ' Day', ' Days',
        # institute  (544 firings)
        ' Institute',
        # fc  (531 firings)
        ' FC', 'FC', 'fc',
        # avenue  (488 firings)
        ' Avenue',
        # riv  (470 firings)
        ' River', ' Riv',
        # cup  (466 firings)
        ' Cup', 'cup',
        # war  (439 firings)
        ' War',
        # army  (411 firings)
        ' Army',
        # tech  (402 firings)
        ' Tech', ' TECH',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'state-family', 1

def prog_L08F08058(input_tokens):
    """18 token families, 41 surface forms (train F1 of the uncapped optimum: 0.304).
    Fires at 100,613 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the number two in various contexts"""
    # --- end external annotation ---
    fire = {
        # two  (12,672 firings)
        ' two', ' Two', 'Two', 'two', ' TWO',
        # three  (5,265 firings)
        ' three', ' Three', 'Three', 'three', ' THREE',
        # few  (3,062 firings)
        ' few',
        # four  (2,989 firings)
        ' four', 'Four',
        # sever  (2,668 firings)
        ' several', ' Several',
        # five  (2,585 firings)
        ' five', 'Five', ' Five',
        # six  (1,587 firings)
        ' six',
        # seven  (1,185 firings)
        ' seven', ' Seven', 'Seven', 'seven',
        # dozen  (1,024 firings)
        ' dozen', ' dozens', 'dozen', ' Dozens',
        # eight  (915 firings)
        ' eight', ' Eight',
        # multiple  (802 firings)
        ' multiple', 'multiple',
        # hundred  (490 firings)
        ' hundreds',
        # nine  (451 firings)
        ' nine',
        # 200  (365 firings)
        ' 200',
        # ten  (349 firings)
        ' ten',
        # twenty  (331 firings)
        ' twenty', 'Twenty', ' Twenty',
        # hundr  (259 firings)
        ' hundred', ' Hundred',
        # numer  (252 firings)
        ' numerous',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'two-family', 1

def prog_L08F08059(input_tokens):
    """25 token families, 60 surface forms (train F1 of the uncapped optimum: 0.215).
    Fires at 90,934 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases related to the movement of liquids or substances"""
    # --- end external annotation ---
    fire = {
        # com  (1,650 firings)
        ' coming', ' Coming', ' Comes',
        # down  (1,079 firings)
        ' down', ' DOWN',
        # going  (858 firings)
        ' going',
        # fall  (705 firings)
        ' fall', ' falling', ' falls', ' Falling',
        # roll  (680 firings)
        ' rolling', ' roll', ' rolled', ' rolls',
        # runn  (656 firings)
        ' running',
        # arriv  (618 firings)
        ' arrived', ' arriving',
        # broke  (569 firings)
        ' broke',
        # pass  (552 firings)
        ' passed', ' passes', ' Passed',
        # flow  (497 firings)
        ' flowing', ' flow', ' flows', ' flowed',
        # fly  (477 firings)
        ' flying', ' fly',
        # spread  (463 firings)
        ' spread', ' spreading', ' spreads',
        # hang  (446 firings)
        ' hanging', ' hangs', ' hang',
        # fell  (383 firings)
        ' fell',
        # arr  (355 firings)
        ' arrive', ' arrives',
        # fir  (297 firings)
        ' fired',
        # pour  (295 firings)
        ' pouring', ' poured', ' pour',
        # float  (289 firings)
        ' floating', ' float', ' floated', ' floats', ' Float',
        # grow  (264 firings)
        ' grow', ' grows',
        # wait  (263 firings)
        ' waiting', ' waits', ' Waiting',
        # rain  (259 firings)
        ' rain', ' raining', ' rains', ' Rain',
        # direct  (258 firings)
        ' directly',
        # popp  (251 firings)
        ' popping', ' popped',
        # leak  (246 firings)
        ' leaked', ' leaking',
        # happen  (228 firings)
        ' happening',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'com-family', 1

def prog_L08F08060(input_tokens):
    """50 token families, 58 surface forms (train F1 of the uncapped optimum: 0.606).
    Fires at 10,781 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of specific individuals, particularly those with the name "Abdul" or "Abdel." """
    # --- end external annotation ---
    fire = {
        # african  (728 firings)
        ' African',
        # ul  (648 firings)
        'ul', ' UL',
        # abdul  (335 firings)
        ' Abdul',
        # mal  (181 firings)
        'Mal', 'MAL',
        # des  (177 firings)
        'Des',
        # del  (176 firings)
        'Del',
        # dil  (167 firings)
        ' Dil',
        # abdel  (154 firings)
        ' Abdel',
        # abd  (148 firings)
        ' Abd',
        # char  (142 firings)
        'CHAR', ' CHAR',
        # dol  (131 firings)
        ' Dol',
        # arra  (129 firings)
        ' arra',
        # mald  (117 firings)
        ' Mald',
        # arabian  (113 firings)
        ' Arabian',
        # detect  (105 firings)
        'Detect', ' Detect',
        # deaf  (98 firings)
        ' deaf',
        # dish  (97 firings)
        ' Dish',
        # methyl  (93 firings)
        ' methyl', 'methyl',
        # alban  (92 firings)
        ' Alban',
        # mohammad  (92 firings)
        ' Mohammad',
        # abel  (92 firings)
        'abel', ' Abel',
        # faul  (89 firings)
        ' Faul',
        # aber  (86 firings)
        ' Aber',
        # exh  (84 firings)
        ' exh',
        # indec  (84 firings)
        ' indec',
        # ال  (83 firings)
        ' ال', 'ال',
        # pred  (76 firings)
        ' Pred', 'Pred',
        # mikhail  (75 firings)
        ' Mikhail',
        # fitz  (72 firings)
        ' Fitz',
        # sul  (72 firings)
        ' Sul',
        # alc  (68 firings)
        ' Alc',
        # desmond  (68 firings)
        ' Desmond',
        # oub  (66 firings)
        'oub',
        # raf  (63 firings)
        'raf',
        # ر  (60 firings)
        'ر',
        # edmund  (59 firings)
        ' Edmund',
        # dianne  (59 firings)
        ' Dianne',
        # nikol  (57 firings)
        ' Nikol',
        # burr  (57 firings)
        ' Burr',
        # adal  (55 firings)
        'adal',
        # abram  (52 firings)
        ' Abram',
        # bout  (51 firings)
        ' Bout',
        # ibur  (51 firings)
        'ibur',
        # ethyl  (50 firings)
        'ethyl',
        # alg  (49 firings)
        ' Alger',
        # duches  (48 firings)
        ' Duchess',
        # morbid  (46 firings)
        ' morbid',
        # inh  (45 firings)
        ' inhal',
        # jam  (42 firings)
        ' Jamal',
        # alm  (34 firings)
        ' Alm',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'african-family', 1

def prog_L08F08061(input_tokens):
    """3 token families, 6 surface forms (train F1 of the uncapped optimum: 0.679).
    Fires at 11,010 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "again." """
    # --- end external annotation ---
    fire = {
        # again  (6,737 firings)
        ' again', ' Again', 'again', 'Again',
        # anew  (36 firings)
        ' anew',
        # reapp  (35 firings)
        ' reapp',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'again-family', 1

def prog_L08F08062(input_tokens):
    """1 token families, 1 surface forms (train F1 of the uncapped optimum: 0.371).
    Fires at 140,944 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "in" across various contexts"""
    # --- end external annotation ---
    fire = {
        # in  (120,240 firings)
        ' in',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'in-family', 1

def prog_L08F08063(input_tokens):
    """17 token families, 19 surface forms (train F1 of the uncapped optimum: 0.142).
    Fires at 68,097 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: prominent names and entities in various contexts, including politics, sports, and business"""
    # --- end external annotation ---
    fire = {
        # trump  (2,788 firings)
        ' Trump',
        # obama  (961 firings)
        ' Obama',
        # clinton  (665 firings)
        ' Clinton',
        # police  (448 firings)
        ' Police',
        # court  (442 firings)
        ' Court',
        # commis  (349 firings)
        ' Commission',
        # china  (323 firings)
        'China',
        # korea  (319 firings)
        ' Korea',
        # more  (306 firings)
        ' MORE',
        # sand  (271 firings)
        ' Sanders',
        # committee  (252 firings)
        ' Committee',
        # russia  (237 firings)
        'Russia',
        # agency  (220 firings)
        ' Agency',
        # fbi  (199 firings)
        ' FBI', 'FBI',
        # israel  (183 firings)
        'Israel',
        # lawmak  (179 firings)
        ' lawmakers', ' lawmaker',
        # service  (173 firings)
        ' Service',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'trump-family', 1

def prog_L08F08064(input_tokens):
    """5 token families, 6 surface forms (train F1 of the uncapped optimum: 0.480).
    Fires at 57,239 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "said" in various contexts"""
    # --- end external annotation ---
    fire = {
        # said  (29,472 firings)
        ' said',
        # say  (1,707 firings)
        ' saying',
        # confirm  (1,466 firings)
        ' confirmed',
        # insist  (243 firings)
        ' insisted', ' insisting',
        # indicat  (208 firings)
        ' indicated',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'said-family', 1

def prog_L08F08065(input_tokens):
    """6 token families, 7 surface forms (train F1 of the uncapped optimum: 0.130).
    Fires at 84,150 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: questions and considerations related to decision-making processes"""
    # --- end external annotation ---
    fire = {
        # what  (2,994 firings)
        ' what',
        # how  (2,526 firings)
        ' how',
        # wheth  (2,524 firings)
        ' whether', 'whether',
        # future  (788 firings)
        ' future',
        # transgend  (272 firings)
        ' transgender',
        # decide  (238 firings)
        ' decide',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'what-family', 1

def prog_L08F08066(input_tokens):
    """1 token families, 1 surface forms (train F1 of the uncapped optimum: 0.270).
    Fires at 128,727 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: statements of being or existence in descriptive contexts"""
    # --- end external annotation ---
    fire = {
        # is  (53,438 firings)
        ' is',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'is-family', 1

def prog_L08F08067(input_tokens):
    """10 token families, 28 surface forms (train F1 of the uncapped optimum: 0.070).
    Fires at 49,527 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to positions of authority or leadership in government"""
    # --- end external annotation ---
    fire = {
        # of  (13,108 firings)
        ' of', ' OF',
        # chair  (468 firings)
        ' chair', ' chaired', 'chair', ' chairs', 'chairs', 'Chair',
        # chairman  (451 firings)
        ' chairman', ' Chairman',
        # committee  (377 firings)
        ' Committee', ' committee',
        # lead  (352 firings)
        ' lead', ' leading', ' leads', 'lead',
        # memb  (328 firings)
        ' member', ' Member', 'member',
        # house  (287 firings)
        ' House',
        # head  (254 firings)
        ' heads', ' headed', ' heading', 'heading',
        # senate  (181 firings)
        ' Senate', ' senate',
        # shadow  (128 firings)
        ' shadow', ' Shadow',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'of-family', 1

def prog_L08F08068(input_tokens):
    """48 token families, 55 surface forms (train F1 of the uncapped optimum: 0.715).
    Fires at 17,387 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to Nebraska and its associations"""
    # --- end external annotation ---
    fire = {
        # ne  (365 firings)
        ' NE', 'Ne',
        # nebraska  (359 firings)
        ' Nebraska',
        # nep  (321 firings)
        ' Nepal', ' Nep', ' nep',
        # ense  (283 firings)
        'ense',
        # hus  (265 firings)
        ' Hus',
        # noah  (240 firings)
        ' Noah',
        # agriculture  (228 firings)
        ' Agriculture',
        # mes  (214 firings)
        ' Mes',
        # indoor  (202 firings)
        ' indoor',
        # milo  (178 firings)
        ' Milo',
        # wendy  (170 firings)
        ' Wendy',
        # dwarf  (168 firings)
        ' dwarf', ' Dwarf',
        # wes  (166 firings)
        ' Wes',
        # mesh  (165 firings)
        ' mesh', ' Mesh', ' meshes', 'Mesh',
        # fry  (160 firings)
        ' Fry',
        # omaha  (146 firings)
        ' Omaha',
        # methane  (139 firings)
        ' methane',
        # bryce  (135 firings)
        ' Bryce',
        # nder  (128 firings)
        'nder',
        # ethan  (127 firings)
        ' Ethan',
        # huffpost  (125 firings)
        ' HuffPost',
        # nitrogen  (117 firings)
        ' nitrogen',
        # fresno  (116 firings)
        ' Fresno',
        # mali  (116 firings)
        ' Mali',
        # mesa  (115 firings)
        ' Mesa',
        # norri  (114 firings)
        ' Norris',
        # kristen  (112 firings)
        ' Kristen',
        # swat  (112 firings)
        ' SWAT',
        # lsu  (109 firings)
        ' LSU',
        # purdue  (107 firings)
        ' Purdue',
        # goat  (106 firings)
        ' goat',
        # peanut  (105 firings)
        ' peanut',
        # gron  (104 firings)
        ' Gron',
        # usda  (103 firings)
        ' USDA',
        # heb  (100 firings)
        ' Heb',
        # betsy  (100 firings)
        ' Betsy',
        # northwestern  (100 firings)
        ' Northwestern',
        # lank  (99 firings)
        ' Lank',
        # hondura  (93 firings)
        ' Honduras',
        # mud  (92 firings)
        ' Mud',
        # sussex  (91 firings)
        ' Sussex',
        # cosmo  (87 firings)
        ' Cosmos',
        # neh  (86 firings)
        ' Neh',
        # woody  (84 firings)
        ' Woody',
        # morton  (84 firings)
        ' Morton',
        # hay  (83 firings)
        ' hay',
        # petraeu  (80 firings)
        ' Petraeus',
        # assy  (75 firings)
        ' Assy',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ne-family', 1

def prog_L08F08069(input_tokens):
    """19 token families, 71 surface forms (train F1 of the uncapped optimum: 0.443).
    Fires at 169,632 of 36,786,566 positions.
    Fires at 0.46% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: technical terms or titles related to performances, services, and structured content"""
    # --- end external annotation ---
    fire = {
        # test  (836 firings)
        ' Test', ' Tests', 'Test', ' Testing', 'Testing', ' TEST',
        # sci  (811 firings)
        ' Science', 'Science', ' Sci',
        # work  (798 firings)
        ' Work', ' Working', 'Work', ' Works', ' Workers', ' Worker', 'Working', 'Works', ' WORK',
        # pow  (776 firings)
        ' Power', ' Powers', 'Power', ' POWER',
        # life  (743 firings)
        ' Life', 'Life', ' LIFE',
        # commun  (742 firings)
        ' Community', 'Community', ' Commun', ' Communities', ' COMMUN',
        # mus  (717 firings)
        ' Music', 'Music', ' Musical',
        # law  (716 firings)
        ' Law', ' Laws', ' LAW',
        # sport  (701 firings)
        ' Sports', ' Sport', ' Sporting', 'Sports', 'Sport',
        # time  (676 firings)
        ' Time', 'Time', ' TIME',
        # home  (661 firings)
        ' Home', 'Home', ' HOME', 'HOME',
        # introduc  (640 firings)
        'Introduction', ' Introduction',
        # play  (604 firings)
        ' Play', ' Player', ' Players', ' Playing', ' Plays', ' PLAY', ' Played',
        # project  (554 firings)
        ' Project', ' Projects', 'Project',
        # championship  (495 firings)
        ' Championship', ' Championships',
        # season  (470 firings)
        ' Season', ' Seasons', 'Season',
        # radio  (456 firings)
        ' Radio', 'Radio',
        # busi  (432 firings)
        ' Business', 'Business',
        # fami  (430 firings)
        ' Family', 'Family',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'test-family', 1

def prog_L08F08070(input_tokens):
    """50 token families, 53 surface forms (train F1 of the uncapped optimum: 0.695).
    Fires at 27,974 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to the cities Mumbai and Shanghai"""
    # --- end external annotation ---
    fire = {
        # moscow  (1,189 firings)
        ' Moscow', 'Moscow',
        # melbourne  (888 firings)
        ' Melbourne',
        # mumbai  (465 firings)
        ' Mumbai',
        # milan  (409 firings)
        ' Milan',
        # munich  (377 firings)
        ' Munich',
        # shanghai  (350 firings)
        ' Shanghai',
        # istanbul  (346 firings)
        ' Istanbul',
        # barcelona  (343 firings)
        ' Barcelona',
        # mcgregor  (252 firings)
        ' McGregor',
        # kar  (238 firings)
        'kar',
        # stockholm  (222 firings)
        ' Stockholm',
        # satan  (217 firings)
        ' Satan', ' Satanic',
        # vienna  (215 firings)
        ' Vienna',
        # petersburg  (207 firings)
        ' Petersburg',
        # vatican  (204 firings)
        ' Vatican',
        # windsor  (188 firings)
        ' Windsor',
        # jacksonville  (188 firings)
        ' Jacksonville',
        # salman  (176 firings)
        ' Salman',
        # frankfurt  (173 firings)
        ' Frankfurt',
        # base  (171 firings)
        ' basement',
        # monaco  (164 firings)
        ' Monaco',
        # parish  (157 firings)
        ' parish',
        # gotham  (155 firings)
        ' Gotham',
        # maharashtra  (154 firings)
        ' Maharashtra',
        # bundesliga  (149 firings)
        ' Bundesliga',
        # wichita  (145 firings)
        ' Wichita',
        # valencia  (144 firings)
        ' Valencia',
        # squadron  (142 firings)
        ' Squadron', ' squadron',
        # stamford  (141 firings)
        ' Stamford',
        # к  (140 firings)
        'к',
        # sochi  (140 firings)
        ' Sochi',
        # serie  (138 firings)
        ' Serie',
        # chennai  (136 firings)
        ' Chennai',
        # phantom  (131 firings)
        ' Phantom',
        # shiv  (127 firings)
        ' Shiv',
        # zurich  (122 firings)
        ' Zurich',
        # meteor  (122 firings)
        ' Meteor',
        # karachi  (120 firings)
        ' Karachi',
        # daytona  (115 firings)
        ' Daytona',
        # chandl  (114 firings)
        ' Chandler',
        # budap  (111 firings)
        ' Budapest',
        # sunset  (111 firings)
        ' Sunset',
        # sharma  (109 firings)
        ' Sharma',
        # bledon  (106 firings)
        'bledon',
        # stanton  (104 firings)
        ' Stanton',
        # deutsche  (104 firings)
        ' Deutsche',
        # ahar  (103 firings)
        'ahar',
        # arkham  (103 firings)
        ' Arkham',
        # bangalore  (102 firings)
        ' Bangalore',
        # balcony  (99 firings)
        ' balcony',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'moscow-family', 1

def prog_L08F08071(input_tokens):
    """15 token families, 32 surface forms (train F1 of the uncapped optimum: 0.261).
    Fires at 342,382 of 36,786,566 positions.
    Fires at 0.93% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases related to significant events or occurrences in society"""
    # --- end external annotation ---
    fire = {
        # -  (4,735 firings)
        '-',
        # to  (2,130 firings)
        ' To', ' TO',
        # follow  (2,016 firings)
        ' Following', ' Follow',
        # '  (1,906 firings)
        "'", " '",
        # new  (1,806 firings)
        ' New', ' NEW', ' Newly',
        # ed  (1,497 firings)
        'ed', 'ED',
        # block  (1,342 firings)
        'block', ' Block', ' Blocks',
        # in  (1,302 firings)
        ' In', ' IN',
        # you  (1,131 firings)
        ' You', ' YOU',
        # is  (1,119 firings)
        ' Is', ' IS',
        # of  (1,103 firings)
        ' Of', ' OF',
        # un  (1,076 firings)
        ' Un',
        # for  (1,021 firings)
        ' For', ' FOR',
        # ock  (1,020 firings)
        'ocked', 'ocking', 'ocks', 'OCK',
        # your  (991 firings)
        ' Your', ' YOUR',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '--family', 1

def prog_L08F08072(input_tokens):
    """41 token families, 52 surface forms (train F1 of the uncapped optimum: 0.654).
    Fires at 12,157 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: mentions of specific hurricanes, particularly Hurricanes Sandy, Katrina, and Maria"""
    # --- end external annotation ---
    fire = {
        # storm  (1,031 firings)
        ' storm', ' storms',
        # hurricane  (886 firings)
        ' Hurricane', ' hurricane',
        # disast  (553 firings)
        ' disaster', ' disasters', ' Disaster',
        # harvey  (470 firings)
        ' Harvey',
        # trop  (357 firings)
        ' tropical', ' Tropical',
        # hurrican  (260 firings)
        ' Hurricanes', ' hurricanes',
        # opioid  (241 firings)
        ' opioid', ' opioids',
        # lebron  (229 firings)
        ' LeBron',
        # destruct  (167 firings)
        ' destructive',
        # radeon  (165 firings)
        ' Radeon',
        # irma  (159 firings)
        ' Irma',
        # torrent  (153 firings)
        ' torrent', ' Torrent',
        # read  (149 firings)
        ' Reader',
        # whale  (145 firings)
        ' whale',
        # tornado  (137 firings)
        ' tornado', ' Tornado',
        # airbu  (136 firings)
        ' Airbus',
        # cycl  (127 firings)
        ' cycl',
        # hur  (124 firings)
        'Hur', 'hur',
        # dictator  (124 firings)
        ' dictator',
        # katrina  (121 firings)
        ' Katrina',
        # batter  (118 firings)
        ' battered',
        # mosquito  (113 firings)
        ' mosquito',
        # meteor  (111 firings)
        ' Meteor',
        # apache  (100 firings)
        ' Apache',
        # wildfire  (91 firings)
        ' wildfire',
        # blist  (88 firings)
        ' blister',
        # typh  (70 firings)
        ' typh', ' Typh',
        # cop  (69 firings)
        ' COP',
        # landfall  (65 firings)
        ' landfall',
        # titan  (65 firings)
        ' Titanic',
        # igator  (63 firings)
        'igator',
        # incendiary  (62 firings)
        ' incendiary',
        # typhoon  (60 firings)
        ' Typhoon',
        # ricane  (54 firings)
        'ricane',
        # vernight  (52 firings)
        'vernight',
        # fema  (51 firings)
        ' FEMA',
        # turbulent  (51 firings)
        ' turbulent',
        # hepatiti  (50 firings)
        ' hepatitis',
        # hms  (43 firings)
        ' HMS',
        # cata  (37 firings)
        ' cataly',
        # clone  (36 firings)
        'clone',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'storm-family', 1

def prog_L08F08073(input_tokens):
    """21 token families, 35 surface forms (train F1 of the uncapped optimum: 0.368).
    Fires at 21,853 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "cross" and its variations, particularly in relation to boundaries or limits"""
    # --- end external annotation ---
    fire = {
        # acros  (1,731 firings)
        ' across',
        # cros  (1,571 firings)
        ' cross', 'cross', 'Cross',
        # cross  (1,335 firings)
        ' crossing', ' crossed', ' crosses', ' Crossing', ' crossings',
        # jump  (388 firings)
        ' jumped', ' jumping', ' jumps',
        # walk  (338 firings)
        ' walked',
        # spill  (184 firings)
        ' spilled', ' spilling',
        # climb  (184 firings)
        ' climb', ' climbing',
        # board  (159 firings)
        ' boarded', ' boarding',
        # part  (153 firings)
        ' parted', ' parting',
        # transc  (115 firings)
        ' transc',
        # crossov  (114 firings)
        ' crossover',
        # touch  (109 firings)
        ' touched',
        # check  (106 firings)
        ' checked',
        # hopp  (88 firings)
        ' hopped', ' hopping',
        # breach  (86 firings)
        ' breached', ' breaching',
        # wander  (83 firings)
        ' wandered',
        # lin  (78 firings)
        ' lined',
        # span  (73 firings)
        ' spans',
        # tipp  (68 firings)
        ' tipping',
        # spann  (63 firings)
        ' spanning',
        # parallel  (58 firings)
        ' parallels',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'acros-family', 1

def prog_L08F08074(input_tokens):
    """33 token families, 48 surface forms (train F1 of the uncapped optimum: 0.584).
    Fires at 15,041 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: variations of the word "kick" in different contexts"""
    # --- end external annotation ---
    fire = {
        # kick  (3,393 firings)
        ' kick', ' kicked', ' kicking', ' kicks', ' Kick', 'kick', ' kicker', 'Kick',
        # ick  (572 firings)
        'icks', 'icking', 'icked',
        # boot  (356 firings)
        ' boot', ' booted',
        # knock  (193 firings)
        ' knocked', ' knocks',
        # rip  (157 firings)
        ' rip', 'rip',
        # jab  (145 firings)
        ' Jab',
        # kickoff  (143 firings)
        ' kickoff',
        # chas  (135 firings)
        ' chased',
        # expell  (127 firings)
        ' expelled',
        # whipp  (109 firings)
        ' whipped', ' whipping',
        # kab  (103 firings)
        ' Kab',
        # pave  (97 firings)
        ' pave',
        # stomp  (90 firings)
        ' stomp',
        # blist  (87 firings)
        ' blister',
        # piss  (85 firings)
        ' pissed',
        # punt  (82 firings)
        ' punt',
        # pepp  (75 firings)
        ' pepp',
        # whip  (75 firings)
        ' whip',
        # capp  (75 firings)
        ' capped',
        # pis  (72 firings)
        ' piss',
        # claw  (72 firings)
        ' claw',
        # kham  (71 firings)
        ' Kham',
        # cock  (66 firings)
        ' Cock',
        # slap  (66 firings)
        ' slap',
        # stab  (63 firings)
        ' Stab', 'stab',
        # kap  (57 firings)
        ' Kap',
        # expel  (55 firings)
        ' expel',
        # drib  (54 firings)
        ' drib',
        # escort  (53 firings)
        ' escorted',
        # pun  (47 firings)
        'pun',
        # expul  (40 firings)
        ' expulsion',
        # lick  (40 firings)
        ' licking', ' lick',
        # kemp  (40 firings)
        ' Kemp',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'kick-family', 1

def prog_L08F08075(input_tokens):
    """25 token families, 48 surface forms (train F1 of the uncapped optimum: 0.147).
    Fires at 41,699 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: specific years or time periods related to historical events or positions"""
    # --- end external annotation ---
    fire = {
        # 2015  (801 firings)
        ' 2015', '2015',
        # 2016  (781 firings)
        ' 2016', '2016',
        # 2012  (707 firings)
        ' 2012', '2012',
        # 2014  (700 firings)
        ' 2014', '2014',
        # 2013  (676 firings)
        ' 2013', '2013',
        # 2011  (457 firings)
        ' 2011', '2011',
        # 2010  (432 firings)
        ' 2010', '2010',
        # 2009  (345 firings)
        ' 2009', '2009',
        # 2018  (308 firings)
        ' 2018', '2018',
        # 2008  (303 firings)
        ' 2008', '2008',
        # 2007  (240 firings)
        ' 2007', '2007',
        # pm  (234 firings)
        'pm', ' pm',
        # season  (232 firings)
        ' seasons',
        # 2000  (218 firings)
        ' 2000', '2000',
        # 2006  (204 firings)
        ' 2006', '2006',
        # 2005  (165 firings)
        ' 2005', '2005',
        # 2020  (164 firings)
        ' 2020', '2020',
        # 2019  (148 firings)
        ' 2019', '2019',
        # 19  (146 firings)
        '19',
        # 1990  (141 firings)
        ' 1990', '1990',
        # 2002  (130 firings)
        ' 2002', '2002',
        # 1980  (124 firings)
        ' 1980', '1980',
        # 2003  (120 firings)
        ' 2003', '2003',
        # 2001  (118 firings)
        ' 2001', '2001',
        # 1970  (113 firings)
        ' 1970', '1970',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '2015-family', 1

def prog_L08F08076(input_tokens):
    """1 token families, 2 surface forms (train F1 of the uncapped optimum: 0.204).
    Fires at 38,984 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases indicating the concept of 'room for' various aspects such as improvement or creativity"""
    # --- end external annotation ---
    fire = {
        # for  (29,626 firings)
        ' for', ' FOR',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'for-family', 1

def prog_L08F08077(input_tokens):
    """47 token families, 55 surface forms (train F1 of the uncapped optimum: 0.640).
    Fires at 11,857 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to various types of spectra"""
    # --- end external annotation ---
    fire = {
        # spectrum  (609 firings)
        ' spectrum', ' Spectrum',
        # montgomery  (305 firings)
        ' Montgomery',
        # syndrome  (278 firings)
        ' syndrome',
        # sand  (210 firings)
        ' sands', ' Sands',
        # receptor  (195 firings)
        ' receptor', ' receptors',
        # lte  (169 firings)
        ' LTE',
        # metadata  (156 firings)
        ' metadata', 'metadata',
        # mickey  (152 firings)
        ' Mickey',
        # wav  (149 firings)
        'waves',
        # siriu  (136 firings)
        ' Sirius',
        # cryst  (132 firings)
        ' crystal',
        # slate  (129 firings)
        ' slate',
        # leslie  (128 firings)
        ' Leslie',
        # bandwidth  (127 firings)
        ' bandwidth',
        # mhz  (127 firings)
        ' MHz', 'MHz',
        # route  (127 firings)
        ' Route', 'Route',
        # seism  (120 firings)
        ' seismic', ' seism',
        # spect  (118 firings)
        ' spect', 'Spect',
        # airspace  (111 firings)
        ' airspace',
        # constella  (104 firings)
        ' constellation',
        # leigh  (100 firings)
        ' Leigh',
        # cassidy  (98 firings)
        ' Cassidy',
        # jazz  (96 firings)
        ' Jazz',
        # navajo  (95 firings)
        ' Navajo',
        # swath  (94 firings)
        ' swath',
        # quire  (93 firings)
        'quire',
        # rock  (87 firings)
        ' Rockies',
        # arn  (85 firings)
        ' Arn',
        # schwartz  (85 firings)
        ' Schwartz',
        # sinclair  (81 firings)
        ' Sinclair',
        # frequenc  (78 firings)
        ' frequencies',
        # zinski  (77 firings)
        'zinski',
        # ghz  (69 firings)
        ' GHz',
        # cortex  (69 firings)
        ' cortex',
        # rez  (63 firings)
        ' Rez',
        # trey  (63 firings)
        ' Trey',
        # myst  (62 firings)
        ' myst',
        # armac  (62 firings)
        'armac',
        # palette  (54 firings)
        ' palette',
        # ing  (53 firings)
        'inges',
        # nic  (53 firings)
        ' nic',
        # modem  (48 firings)
        ' modem',
        # nebula  (47 firings)
        ' Nebula',
        # metast  (46 firings)
        ' metast',
        # malone  (45 firings)
        ' Malone',
        # otom  (44 firings)
        'otom',
        # ambigu  (39 firings)
        ' ambiguity',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'spectrum-family', 1

def prog_L08F08078(input_tokens):
    """35 token families, 71 surface forms (train F1 of the uncapped optimum: 0.427).
    Fires at 44,763 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases that emphasize approximation or near certainty"""
    # --- end external annotation ---
    fire = {
        # almost  (2,255 firings)
        ' almost', 'Almost', ' Almost', 'almost',
        # near  (1,765 firings)
        ' nearly', 'Nearly', ' Nearly', 'Near',
        # quite  (908 firings)
        ' quite', ' Quite', 'Quite', 'quite',
        # many  (851 firings)
        'Many',
        # yet  (845 firings)
        ' Yet', 'Yet',
        # much  (685 firings)
        'Much', ' Much', 'much',
        # still  (659 firings)
        ' Still', 'Still',
        # perhap  (652 firings)
        'Perhaps', ' Perhaps',
        # ever  (568 firings)
        'Ever', ' Ever',
        # very  (512 firings)
        ' Very', 'Very', 'very',
        # just  (451 firings)
        'Just',
        # un  (443 firings)
        'Un',
        # rath  (387 firings)
        ' Rather', 'Rather',
        # les  (369 firings)
        'Less', ' Less', 'LESS',
        # part  (327 firings)
        'Part', ' Partial',
        # twenty  (260 firings)
        'Twenty', ' Twenty',
        # often  (257 firings)
        ' Often', 'Often',
        # probab  (222 firings)
        ' Probably', 'Probably', 'probably',
        # sometim  (216 firings)
        'Sometimes',
        # apparent  (213 firings)
        'Apparently', ' Apparently',
        # too  (211 firings)
        'Too', ' Too',
        # only  (204 firings)
        'Only',
        # usual  (195 firings)
        'Usually', ' Usually',
        # neith  (193 firings)
        ' Neither', 'Neither',
        # half  (189 firings)
        'Half', ' Half',
        # known  (188 firings)
        'Known', ' Known',
        # already  (185 firings)
        'Already', ' Already',
        # nev  (170 firings)
        'Never',
        # few  (164 firings)
        'Few',
        # short  (163 firings)
        'Shortly', ' Shortly',
        # basical  (160 firings)
        'Basically', ' Basically',
        # pretty  (153 firings)
        ' Pretty', 'Pretty',
        # especial  (149 firings)
        ' Especially', 'Especially',
        # noth  (142 firings)
        'Nothing',
        # maybe  (131 firings)
        'Maybe',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'almost-family', 1

def prog_L08F08079(input_tokens):
    """42 token families, 60 surface forms (train F1 of the uncapped optimum: 0.633).
    Fires at 14,401 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: occurrences of the word "drag" in various contexts"""
    # --- end external annotation ---
    fire = {
        # drag  (712 firings)
        ' drag', ' Drag', 'Drag', ' DRAG',
        # opera  (371 firings)
        ' opera', ' Opera',
        # rub  (336 firings)
        ' Rub', 'Rub',
        # dragg  (266 firings)
        ' dragged', ' dragging',
        # ru  (233 firings)
        ' Ru', 'Ru',
        # rac  (229 firings)
        ' Rac', ' racer',
        # redirect  (225 firings)
        ' redirect',
        # custom  (218 firings)
        ' Customs',
        # rack  (205 firings)
        ' rack', ' Rack', ' racks',
        # cos  (168 firings)
        'Cos', ' Cos',
        # dr  (167 firings)
        'dr',
        # ig  (164 firings)
        ' Ig', ' IG',
        # cub  (138 firings)
        ' Cub',
        # bra  (134 firings)
        ' Bras', ' bras',
        # gomez  (124 firings)
        ' Gomez',
        # hod  (121 firings)
        ' Hod',
        # rag  (118 firings)
        'rag', ' Rag', 'RAG',
        # craw  (115 firings)
        ' craw', ' Craw',
        # barb  (112 firings)
        ' Barber', ' Barb',
        # hug  (112 firings)
        'Hug', ' Hug',
        # dug  (110 firings)
        ' Dug',
        # lewd  (109 firings)
        ' lewd',
        # hip  (104 firings)
        ' Hip',
        # tug  (102 firings)
        ' tug',
        # acht  (102 firings)
        'acht',
        # drum  (101 firings)
        ' Drum',
        # mot  (99 firings)
        ' mot',
        # bian  (97 firings)
        ' Bian',
        # armac  (89 firings)
        'armac',
        # zin  (86 firings)
        ' Zin',
        # asp  (79 firings)
        ' ASP',
        # queen  (78 firings)
        ' queens',
        # igor  (78 firings)
        ' Igor',
        # borg  (78 firings)
        ' Borg',
        # salon  (73 firings)
        ' salon',
        # grimm  (68 firings)
        ' Grimm',
        # cadillac  (65 firings)
        ' Cadillac',
        # cor  (63 firings)
        ' Cors',
        # men  (62 firings)
        ' Mens',
        # ng  (61 firings)
        ' ng',
        # rez  (53 firings)
        ' Rez',
        # yg  (49 firings)
        'yg',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'drag-family', 1

def prog_L08F08080(input_tokens):
    """4 token families, 6 surface forms (train F1 of the uncapped optimum: 0.370).
    Fires at 14,489 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: the repetition of the phrase "over the years." """
    # --- end external annotation ---
    fire = {
        # year  (8,701 firings)
        ' years', ' Years', 'Years',
        # decad  (905 firings)
        ' decades',
        # generation  (129 firings)
        ' generations',
        # wiv  (49 firings)
        'wives',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'year-family', 1

def prog_L08F08081(input_tokens):
    """9 token families, 20 surface forms (train F1 of the uncapped optimum: 0.164).
    Fires at 177,903 of 36,786,566 positions.
    Fires at 0.48% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to books and their authors"""
    # --- end external annotation ---
    fire = {
        # the  (6,247 firings)
        ' The',
        # "  (3,576 firings)
        ' "',
        # new  (1,487 firings)
        ' New', ' Newly',
        # why  (990 firings)
        'Why', ' Why', ' WHY', 'why',
        # american  (859 firings)
        ' American', 'American',
        # &  (707 firings)
        ' &',
        # how  (670 firings)
        ' How', 'How', 'HOW', ' HOW',
        # black  (512 firings)
        ' Black', 'Black', ' BLACK',
        # is  (503 firings)
        ' Is', 'Is',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'the-family', 1

def prog_L08F08082(input_tokens):
    """3 token families, 3 surface forms (train F1 of the uncapped optimum: 0.271).
    Fires at 8,933 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: segments of text that involve the concept of "part" or participation in an action or event"""
    # --- end external annotation ---
    fire = {
        # part  (3,288 firings)
        ' part',
        # entirety  (34 firings)
        ' entirety',
        # pain  (23 firings)
        ' pains',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'part-family', 1

def prog_L08F08083(input_tokens):
    """46 token families, 56 surface forms (train F1 of the uncapped optimum: 0.631).
    Fires at 30,646 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: terms related to awkwardness and embarrassment"""
    # --- end external annotation ---
    fire = {
        # embarrass  (664 firings)
        ' embarrassing', ' embarrassed', ' embarrassment',
        # annoy  (552 firings)
        ' annoying', ' annoyed', ' annoy', ' annoyance',
        # ugly  (423 firings)
        ' ugly',
        # awkward  (420 firings)
        ' awkward', ' awkwardly',
        # pain  (399 firings)
        ' painful',
        # unfortunate  (355 firings)
        ' unfortunate',
        # disappoint  (352 firings)
        ' disappointing',
        # convenient  (351 firings)
        ' convenient', ' conveniently',
        # frustrat  (328 firings)
        ' frustrating',
        # setback  (328 firings)
        ' setback', ' setbacks',
        # uncomfort  (305 firings)
        ' uncomfortable',
        # awful  (283 firings)
        ' awful',
        # cost  (254 firings)
        ' costly',
        # nasty  (247 firings)
        ' nasty',
        # unpopular  (224 firings)
        ' unpopular',
        # hat  (213 firings)
        ' hated', ' hates',
        # hilari  (208 firings)
        ' hilarious',
        # unwant  (184 firings)
        ' unwanted',
        # contenti  (183 firings)
        ' contentious',
        # bor  (179 firings)
        ' boring',
        # invas  (160 firings)
        ' invasive',
        # humiliat  (158 firings)
        ' humiliating', ' humiliated',
        # unpleasant  (143 firings)
        ' unpleasant',
        # messy  (141 firings)
        ' messy',
        # boo  (141 firings)
        ' boo',
        # unnecessary  (137 firings)
        ' unnecessary',
        # inappropriate  (134 firings)
        ' inappropriate',
        # headache  (129 firings)
        ' headache',
        # unhappy  (124 firings)
        ' unhappy',
        # headach  (123 firings)
        ' headaches',
        # traumat  (121 firings)
        ' traumatic',
        # miser  (121 firings)
        ' miserable',
        # amus  (115 firings)
        ' amusing',
        # unaccept  (114 firings)
        ' unacceptable',
        # discomfort  (112 firings)
        ' discomfort',
        # infuri  (109 firings)
        ' infuri',
        # dislike  (109 firings)
        ' dislike',
        # distrac  (109 firings)
        ' distraction',
        # undo  (105 firings)
        ' undo',
        # tedi  (104 firings)
        ' tedious',
        # abrupt  (104 firings)
        ' abrupt',
        # stress  (102 firings)
        ' stressful',
        # painful  (97 firings)
        ' painfully',
        # unsettl  (93 firings)
        ' unsettling',
        # embarras  (90 firings)
        ' embarrass',
        # debilitat  (87 firings)
        ' debilitating',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'embarrass-family', 1

def prog_L08F08084(input_tokens):
    """44 token families, 53 surface forms (train F1 of the uncapped optimum: 0.591).
    Fires at 13,652 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "exploit" and its variations, indicating a focus on discussing abuse or taking advantage of something"""
    # --- end external annotation ---
    fire = {
        # exploit  (827 firings)
        ' exploit', ' exploited', ' exploits', ' exploiting',
        # abus  (309 firings)
        ' abused', ' abusing',
        # bypas  (234 firings)
        ' bypass',
        # exploita  (230 firings)
        ' exploitation',
        # exot  (217 firings)
        ' exotic',
        # vulner  (216 firings)
        ' vulnerability',
        # expl  (212 firings)
        ' Expl',
        # har  (208 firings)
        ' harness',
        # leverage  (208 firings)
        ' leverage',
        # comprom  (201 firings)
        ' compromised',
        # vulnerabil  (196 firings)
        ' vulnerabilities',
        # util  (178 firings)
        ' util', ' utilized', ' utilization',
        # reproduc  (140 firings)
        ' reproduced', ' reproduction',
        # lev  (134 firings)
        ' lever', ' Lever',
        # equ  (132 firings)
        ' Equ',
        # utilize  (119 firings)
        ' utilize',
        # loophole  (112 firings)
        ' loophole',
        # lucrat  (110 firings)
        ' lucrative',
        # oit  (105 firings)
        'oit',
        # zion  (103 firings)
        ' Zion',
        # circumvent  (95 firings)
        ' circumvent',
        # reproduce  (91 firings)
        ' reproduce',
        # capitalize  (90 firings)
        ' capitalize',
        # manipulat  (84 firings)
        ' manipulated',
        # exaggerat  (83 firings)
        ' exaggerated',
        # cultivat  (83 firings)
        ' cultivated', ' cultivating',
        # engineer  (82 firings)
        ' engineered',
        # manipula  (79 firings)
        ' manipulation',
        # loophol  (77 firings)
        ' loopholes',
        # leverag  (66 firings)
        ' leveraging',
        # penetra  (66 firings)
        ' penetration',
        # fetish  (60 firings)
        ' fetish',
        # inflat  (58 firings)
        ' inflated',
        # cv  (54 firings)
        ' CV',
        # opportun  (54 firings)
        ' opportun',
        # ploy  (52 firings)
        ' ploy',
        # exacerbat  (47 firings)
        ' exacerbated',
        # overflow  (46 firings)
        ' overflow',
        # reprodu  (46 firings)
        ' reprodu',
        # patch  (43 firings)
        ' patched',
        # emula  (41 firings)
        ' emulation',
        # explo  (40 firings)
        ' explo',
        # workaround  (40 firings)
        ' workaround',
        # reciproc  (37 firings)
        ' reciproc',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'exploit-family', 1

def prog_L08F08085(input_tokens):
    """48 token families, 76 surface forms (train F1 of the uncapped optimum: 0.687).
    Fires at 90,650 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: terms related to opposition, complaints, and historical context"""
    # --- end external annotation ---
    fire = {
        # ad  (1,098 firings)
        'Ad',
        # con  (1,095 firings)
        'Con', 'Cons', 'cons', ' Cons', 'CON',
        # ex  (828 firings)
        'Ex',
        # sen  (803 firings)
        'Sen',
        # un  (753 firings)
        'Un',
        # rep  (753 firings)
        'Rep', 'REP',
        # re  (695 firings)
        'Re',
        # pre  (642 firings)
        'Pre', 'Pres', ' Pres', 'pres', 'PRE', 'PRES',
        # don  (627 firings)
        'Don',
        # pro  (599 firings)
        'Pro',
        # int  (569 firings)
        'Int', 'Inter', 'INTER',
        # cl  (558 firings)
        'Cl',
        # tran  (502 firings)
        'Trans',
        # cont  (484 firings)
        'Cont', ' Cont', 'CONT',
        # com  (470 firings)
        'Com', 'Comment', ' Comed',
        # pl  (446 firings)
        'Pl',
        # se  (444 firings)
        'Se',
        # per  (434 firings)
        'Per', 'Pers',
        # sp  (420 firings)
        'Sp',
        # part  (417 firings)
        'Part',
        # dr  (402 firings)
        'Dr',
        # law  (401 firings)
        'Law',
        # comp  (397 firings)
        'Comp', ' Comp', 'comp',
        # co  (396 firings)
        'Co',
        # activ  (394 firings)
        'Activ', ' Activ', 'activ',
        # tr  (389 firings)
        'Tr',
        # ann  (372 firings)
        'Ann', 'ANN',
        # app  (365 firings)
        'App',
        # dis  (354 firings)
        'Dis', 'DIS', ' Diss',
        # te  (348 firings)
        'Te',
        # def  (336 firings)
        'Def',
        # gu  (333 firings)
        'Gu',
        # sub  (328 firings)
        'Sub',
        # sc  (319 firings)
        'Sc',
        # col  (311 firings)
        'Col',
        # spe  (310 firings)
        'Spe', ' Spe',
        # rec  (306 firings)
        'Rec', 'REC',
        # sur  (305 firings)
        'Sur',
        # ind  (305 firings)
        'Ind',
        # min  (300 firings)
        'Min',
        # tim  (300 firings)
        'Tim',
        # pat  (294 firings)
        'Pat',
        # dec  (288 firings)
        'Dec', 'DEC',
        # dep  (281 firings)
        'Dep',
        # att  (272 firings)
        'Att',
        # ill  (271 firings)
        'Ill',
        # im  (263 firings)
        'Im',
        # phot  (248 firings)
        'Phot', 'phot',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ad-family', 1

def prog_L08F08086(input_tokens):
    """42 token families, 59 surface forms (train F1 of the uncapped optimum: 0.652).
    Fires at 11,856 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: technical terms or abbreviations related to a specific field of study"""
    # --- end external annotation ---
    fire = {
        # ec  (1,499 firings)
        'EC', 'ec', ' EC', ' ec', ' Ec',
        # ea  (568 firings)
        ' EA', 'EA',
        # em  (351 firings)
        'EM', ' EM',
        # cloud  (348 firings)
        ' Cloud', 'Cloud',
        # ce  (278 firings)
        'CE', ' CE',
        # aca  (199 firings)
        'ACA', ' ACA',
        # aws  (177 firings)
        ' AWS',
        # fx  (174 firings)
        'FX', ' FX',
        # ij  (167 firings)
        'IJ',
        # electro  (157 firings)
        ' electro', ' Electro', ' electroly',
        # wc  (150 firings)
        'WC', ' WC',
        # fi  (144 firings)
        ' FI', 'FI',
        # ecb  (126 firings)
        ' ECB',
        # petro  (125 firings)
        ' Petro',
        # ic  (120 firings)
        ' IC',
        # fia  (118 firings)
        ' FIA',
        # decree  (110 firings)
        ' decree',
        # crawford  (103 firings)
        ' Crawford',
        # form  (103 firings)
        'Form', 'FORM', ' FORM',
        # ge  (99 firings)
        ' GE',
        # conc  (98 firings)
        ' CONC',
        # ab  (96 firings)
        ' AB',
        # ober  (94 firings)
        ' Ober',
        # ee  (93 firings)
        ' EE',
        # orche  (88 firings)
        ' orche', ' Orche',
        # ei  (83 firings)
        'ei',
        # cri  (79 firings)
        ' Cris',
        # eva  (75 firings)
        'EVA',
        # seaw  (75 firings)
        ' seaw',
        # ems  (73 firings)
        ' EMS',
        # dw  (70 firings)
        ' DW',
        # xia  (69 firings)
        ' Xia',
        # fec  (65 firings)
        ' FEC',
        # crom  (61 firings)
        ' Crom',
        # ant  (60 firings)
        ' antic',
        # tec  (59 firings)
        ' Tec',
        # ecake  (54 firings)
        'ecake',
        # fisa  (52 firings)
        ' FISA',
        # nec  (51 firings)
        ' NEC',
        # scaff  (49 firings)
        ' scaff',
        # neoc  (46 firings)
        ' neoc',
        # alec  (40 firings)
        ' ALEC',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'ec-family', 1

def prog_L08F08087(input_tokens):
    """17 token families, 27 surface forms (train F1 of the uncapped optimum: 0.101).
    Fires at 125,759 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: adjectives that describe essential characteristics or qualities"""
    # --- end external annotation ---
    fire = {
        # a  (5,540 firings)
        ' a',
        # up  (903 firings)
        ' up',
        # used  (902 firings)
        ' used',
        # known  (646 firings)
        ' known', 'known',
        # part  (570 firings)
        ' part', ' partly',
        # best  (564 firings)
        ' best',
        # avail  (534 firings)
        ' available',
        # direct  (467 firings)
        ' direct', ' directly', 'direct',
        # good  (437 firings)
        ' good',
        # very  (420 firings)
        ' very', ' VERY',
        # well  (413 firings)
        ' well',
        # place  (412 firings)
        ' place',
        # close  (390 firings)
        ' close', ' closely', 'close',
        # hard  (378 firings)
        ' hard', ' harder', 'hard',
        # little  (358 firings)
        ' little', 'little',
        # bett  (344 firings)
        ' better',
        # involv  (343 firings)
        ' involved',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'a-family', 1

def prog_L08F08088(input_tokens):
    """2 token families, 3 surface forms (train F1 of the uncapped optimum: 0.065).
    Fires at 31,361 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases indicating the necessity of time for various actions or processes"""
    # --- end external annotation ---
    fire = {
        # to  (23,212 firings)
        ' to', ' TO',
        # furth  (217 firings)
        ' further',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'to-family', 1

def prog_L08F08089(input_tokens):
    """41 token families, 46 surface forms (train F1 of the uncapped optimum: 0.496).
    Fires at 13,801 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to phenomena or significant occurrences"""
    # --- end external annotation ---
    fire = {
        # phenomenon  (689 firings)
        ' phenomenon',
        # syndrome  (369 firings)
        ' syndrome', ' Syndrome',
        # sensa  (269 firings)
        ' sensation',
        # epidem  (255 firings)
        ' epidemic',
        # paradox  (207 firings)
        ' paradox', ' Paradox',
        # spectacle  (181 firings)
        ' spectacle',
        # forma  (153 firings)
        ' formation', ' Formation',
        # phenomena  (147 firings)
        ' phenomena',
        # itu  (125 firings)
        'itus',
        # occurr  (124 firings)
        ' occurrence',
        # characteristic  (121 firings)
        ' characteristics',
        # fam  (120 firings)
        ' Fam',
        # myster  (112 firings)
        ' mysteries',
        # sight  (104 firings)
        ' sightings',
        # phen  (99 firings)
        ' Phen', ' phen',
        # formation  (96 firings)
        ' formations',
        # wond  (96 firings)
        ' wonders', ' Wonders',
        # meme  (92 firings)
        ' meme',
        # commonplace  (90 firings)
        ' commonplace',
        # hoax  (88 firings)
        ' hoax',
        # anoma  (84 firings)
        ' anomaly',
        # novelty  (82 firings)
        ' novelty',
        # hysteria  (75 firings)
        ' hysteria',
        # mad  (75 firings)
        ' madness',
        # scourge  (69 firings)
        ' scourge',
        # menace  (61 firings)
        ' menace',
        # stimuli  (58 firings)
        ' stimuli',
        # paradigm  (56 firings)
        ' paradigm',
        # trope  (52 firings)
        ' trope',
        # rar  (51 firings)
        ' rarity',
        # ich  (50 firings)
        ' Ich',
        # hazard  (48 firings)
        ' hazards',
        # anomal  (47 firings)
        ' anomalies',
        # fiasco  (45 firings)
        ' fiasco',
        # sensation  (43 firings)
        ' sensations',
        # manifesta  (43 firings)
        ' manifestation',
        # iae  (41 firings)
        'iae',
        # relic  (40 firings)
        ' relics',
        # sas  (39 firings)
        ' Sas',
        # fallacy  (37 firings)
        ' fallacy',
        # jah  (36 firings)
        ' Jah',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'phenomenon-family', 1

def prog_L08F08090(input_tokens):
    """8 token families, 10 surface forms (train F1 of the uncapped optimum: 0.104).
    Fires at 28,878 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases indicating causation or conditions leading to certain outcomes"""
    # --- end external annotation ---
    fire = {
        # cit  (716 firings)
        ' citing', ' cited',
        # follow  (546 firings)
        ' following',
        # despite  (381 firings)
        ' despite',
        # due  (285 firings)
        ' due',
        # avoid  (241 firings)
        ' avoid',
        # iting  (185 firings)
        'iting',
        # amid  (161 firings)
        ' amid',
        # flee  (160 firings)
        ' fleeing', ' flee',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'cit-family', 1

def prog_L08F08091(input_tokens):
    """26 token families, 31 surface forms (train F1 of the uncapped optimum: 0.232).
    Fires at 97,045 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: incidents involving gunfire or shooting"""
    # --- end external annotation ---
    fire = {
        # fire  (1,592 firings)
        ' fire', 'fire', ' FIRE',
        # dead  (824 firings)
        ' dead',
        # action  (822 firings)
        ' action', ' ACTION',
        # money  (796 firings)
        ' money',
        # control  (751 firings)
        ' control',
        # war  (748 firings)
        ' war',
        # guilty  (689 firings)
        ' guilty',
        # sale  (612 firings)
        ' sale',
        # sex  (556 firings)
        ' sex',
        # fun  (549 firings)
        ' fun',
        # debut  (521 firings)
        ' debut',
        # vir  (435 firings)
        ' viral',
        # contract  (434 firings)
        ' contract',
        # effect  (430 firings)
        ' effect',
        # lawsuit  (395 firings)
        ' lawsuit',
        # street  (363 firings)
        ' streets',
        # tri  (356 firings)
        ' trial',
        # respons  (348 firings)
        ' responsibility', 'responsive',
        # attack  (336 firings)
        ' attacked',
        # contact  (322 firings)
        ' contact',
        # surgery  (296 firings)
        ' surgery',
        # door  (288 firings)
        ' doors',
        # weight  (285 firings)
        ' weight', ' weights',
        # birth  (268 firings)
        ' birth',
        # suit  (266 firings)
        ' suit',
        # suicide  (258 firings)
        ' suicide',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'fire-family', 1

def prog_L08F08092(input_tokens):
    """5 token families, 9 surface forms (train F1 of the uncapped optimum: 0.745).
    Fires at 5,869 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "enough." """
    # --- end external annotation ---
    fire = {
        # enough  (4,571 firings)
        ' enough', ' Enough', 'Enough', 'enough',
        # sufficient  (316 firings)
        ' sufficient', ' sufficiently',
        # insufficient  (62 firings)
        ' insufficient',
        # leftov  (25 firings)
        ' leftover',
        # ufficient  (20 firings)
        'ufficient',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'enough-family', 1

def prog_L08F08093(input_tokens):
    """16 token families, 24 surface forms (train F1 of the uncapped optimum: 0.116).
    Fires at 77,180 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: references to specific dates and times"""
    # --- end external annotation ---
    fire = {
        # on  (6,599 firings)
        ' on',
        # time  (1,508 firings)
        ' time',
        # th  (1,469 firings)
        'th', ' th',
        # p  (1,388 firings)
        ' p',
        # every  (1,089 firings)
        ' every', ' Every',
        # ear  (1,059 firings)
        ' early',
        # late  (833 firings)
        ' late', 'late',
        # each  (799 firings)
        ' each', ' Each', 'Each',
        # next  (663 firings)
        ' next',
        # morn  (591 firings)
        ' morning', 'morning',
        # hour  (579 firings)
        ' hours',
        # saturday  (443 firings)
        ' Saturday', ' Saturdays',
        # even  (259 firings)
        ' evening', ' evenings',
        # 30  (241 firings)
        '30',
        # christma  (222 firings)
        ' Christmas',
        # middle  (221 firings)
        ' middle',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'on-family', 1

def prog_L08F08094(input_tokens):
    """1 token families, 1 surface forms (train F1 of the uncapped optimum: 0.195).
    Fires at 88,503 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: the indefinite article "a" used in various contexts"""
    # --- end external annotation ---
    fire = {
        # a  (71,509 firings)
        ' a',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'a-family', 1

def prog_L08F08095(input_tokens):
    """22 token families, 55 surface forms (train F1 of the uncapped optimum: 0.214).
    Fires at 126,301 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: specific terms related to medical and health topics"""
    # --- end external annotation ---
    fire = {
        # f  (2,125 firings)
        'F', ' F', 'f',
        # p  (2,034 firings)
        'P', ' P', 'p',
        # c  (2,003 firings)
        'C', 'c', ' c',
        # b  (1,611 firings)
        'B', 'b',
        # g  (1,398 firings)
        'G', 'g',
        # l  (1,144 firings)
        'L', 'l',
        # h  (1,091 firings)
        'H',
        # t  (1,010 firings)
        'T',
        # d  (911 firings)
        'D',
        # r  (833 firings)
        'R',
        # sp  (603 firings)
        ' Sp', 'Sp', 'sp', ' SP',
        # v  (543 firings)
        'V',
        # sc  (532 firings)
        ' Sc', 'sc', 'Sc', ' SC',
        # te  (525 firings)
        'te', 'Te', ' Te', ' te', ' TE',
        # w  (514 firings)
        'W',
        # sh  (504 firings)
        'Sh', 'sh', ' SH',
        # co  (496 firings)
        'co', 'Co', ' CO',
        # u  (442 firings)
        'U',
        # cl  (426 firings)
        'cl', 'Cl', ' Cl', ' CL',
        # ch  (388 firings)
        'Ch', ' CH',
        # dr  (386 firings)
        'Dr', 'dr', ' DR',
        # con  (371 firings)
        'Cons', 'Con', 'cons', ' Cons', ' CON',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'f-family', 1

def prog_L08F08096(input_tokens):
    """8 token families, 10 surface forms (train F1 of the uncapped optimum: 0.649).
    Fires at 10,365 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: numerical values, particularly those associated with thresholds or measurements"""
    # --- end external annotation ---
    fire = {
        # 0  (6,344 firings)
        ' 0', '0',
        # 00  (254 firings)
        ' 00',
        # ft  (118 firings)
        'FT',
        # enrique  (80 firings)
        ' Enrique',
        # nil  (74 firings)
        ' Nil', ' nil',
        # toby  (52 firings)
        ' Toby',
        # //  (44 firings)
        '//',
        # sleepy  (36 firings)
        ' sleepy',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return '0-family', 1

def prog_L08F08097(input_tokens):
    """11 token families, 19 surface forms (train F1 of the uncapped optimum: 0.100).
    Fires at 240,929 of 36,786,566 positions.
    Fires at 0.65% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: phrases that discuss situations or conditions that are recurring or typical"""
    # --- end external annotation ---
    fire = {
        # in  (7,169 firings)
        ' in',
        # one  (2,015 firings)
        ' one', ' ones',
        # first  (1,587 firings)
        ' first', ' FIRST',
        # just  (1,117 firings)
        ' just', ' JUST',
        # last  (1,013 firings)
        ' last', ' LAST',
        # only  (888 firings)
        ' only', 'only',
        # many  (826 firings)
        ' many',
        # great  (662 firings)
        ' great', ' greatest', ' GREAT',
        # part  (656 firings)
        ' part', ' partly',
        # good  (651 firings)
        ' good',
        # among  (606 firings)
        ' among',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'in-family', 1

def prog_L08F08098(input_tokens):
    """11 token families, 37 surface forms (train F1 of the uncapped optimum: 0.138).
    Fires at 231,175 of 36,786,566 positions.
    Fires at 0.63% of positions, and
    token rules do not serve features this dense: median test F1 0.086
    across the 37,173 features above 0.39% of positions, against 0.763 for
    the 76,283 below 0.016%. Read this fire set as the best available
    approximation, not as what the feature does."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: patterns related to dietary habits and food consumption"""
    # --- end external annotation ---
    fire = {
        # to  (8,098 firings)
        ' to',
        # time  (1,566 firings)
        ' time', 'time',
        # day  (1,507 firings)
        ' day', ' days', 'day', 'Day', ' Days',
        # eat  (1,197 firings)
        ' eat', ' eating', ' eats', ' Eat', ' Eating', 'Eat', 'eating', 'eat',
        # your  (1,072 firings)
        ' your', ' Your', ' YOUR',
        # diet  (797 firings)
        ' diet', ' diets', ' Diet',
        # dur  (787 firings)
        ' during',
        # dai  (741 firings)
        ' daily', 'daily', 'Daily',
        # hour  (685 firings)
        ' hours', ' hour', 'hour', 'Hour',
        # every  (636 firings)
        ' every', ' Every', 'every',
        # food  (603 firings)
        ' food', ' foods', 'food', 'Food',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'to-family', 1

def prog_L08F08099(input_tokens):
    """6 token families, 14 surface forms (train F1 of the uncapped optimum: 0.675).
    Fires at 15,921 of 36,786,566 positions."""
    # --- begin external annotation (ignored at runtime) ---
    """prev SAE description: instances of the word "share." """
    # --- end external annotation ---
    fire = {
        # share  (5,512 firings)
        ' share', 'Share', ' Share', 'share',
        # shar  (4,025 firings)
        ' shared', ' sharing', ' shares', 'sharing', ' Sharing', 'shared',
        # publish  (195 firings)
        ' publish',
        # selfie  (100 firings)
        ' selfie',
        # self  (54 firings)
        ' selfies',
        # exchang  (46 firings)
        ' exchanging',
    }
    token = input_tokens[-1]
    if token not in fire:
        return "no match", 0
    return 'share-family', 1