---
 # Note to translators:
 #   most languages don't have two ways to pronounce 'a' -- if not need, remove the rules and change "B-Z" to "A-Z"
 #   some languages say the word for "uppercase" after the letter. Make sure to change that where appropriate by moving some code around
 - "a-z": 
    - test: 
        if: "$TTS='none'"
        then: [T: "."]                          	# 	(en: '.', DeepL translation)
        else: [SPELL: "'.'"]                       

 # Capital letters are a little tricky: users can pick their favorite word (something that was requested) and 
 # screen readers have options to use pitch changes or beeps instead of or in addition to say "cap"
 # Also, if a user can see the screen, they probably don't need to hear "cap", but if they specified an override, they must want to hear the override.
            
 - "A-Z":
    - test: 
        if: "$CapitalLetters_Beep"
        then:
        - audio:
            value: "beep.mp4"
            replace: []
    - pitch:
        value: "$CapitalLetters_Pitch"
        # note: processing of ranges converts '.' into the character, so it needs to be in quotes below
        replace: [SPELL: "translate('.', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"]
    - test: 
        if: "$CapitalLetters_UseWord"
        then_test:
          if: "$SpeechOverrides_CapitalLetters = ''"
          then_test:
            if: "$Impairment = 'Blindness'"
            then: [T: "majuscule"]              	# 	(en: 'cap', DeepL translation)
          else: [x: "$SpeechOverrides_CapitalLetters"]

 - "0-9": [T: "."]                              	# 	(en: '.', DeepL: 'A')

 - " ": [T: " "]                           	        #  0x20	(en: ' ', DeepL: ' ')

 - "!":                                         	#  0x21
    - test:
        if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')]"
        then_test:
            if: "$Verbosity = 'Terse'"
            then: [T: "bang"]                   	#  0x21	(DeepL translation)
            else: [T: "point d'exclamation"]        #  0x21	(en: 'exclamation point')
        else: [T: "factorielle"]                	#  0x21	(en: 'factorial')
          
 - "\"": [T: "guillemet"]          	                #  0x22	(en: 'quotation mark')
 - "#": [T: "dièse"]                            	#  0x23	(en: 'number')
 - "$": [T: "dollar"]                          	    #  0x24
 - "%": [T: "pourcent"]                         	#  0x25	(en: 'percent')
 - "&": [T: "esperluette"]                      	#  0x26	(en: 'ampersand')
 - "'": [T: "apostrophe"]                       	#  0x27	(SRE: 'prime')
 - "(":                                         	#  0x28
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then_test:
            if: "$Verbosity='Terse'"
            then: [T: "ouvert"]                 	#  0x28	(en: 'open', DeepL translation)
            else: [T: "parenthèse gauche"]      	#  0x28	(en: 'open paren', MathPlayer: 'parenthèse ouvrante', DeepL: 'parenthèse ouverte')
        else: [T: "parenthèse gauche"]          	#  0x28	(en: 'left paren', MathPlayer: 'parenthèse ouvrante')
 - ")":                                         	#  0x29
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then_test:
            if: "$Verbosity='Terse'"
            then: [T: "fermer"]                 	#  0x29	(en: 'close', DeepL translation)
            else: [T: "parenthèse droite"]      	#  0x29	(en: 'close paren', MathPlayer: 'parenthèse fermante', DeepL: 'parenthèse fermée')
        else: [T: "parenthèse droite"]          	#  0x29	(en: 'right paren', MathPlayer: 'parenthèse fermante')

 - "*":                                         	#  0x2a
    test:
        if: "parent::*[name(.)='msup' or name(.)='msubsup' or name(.)='skip-super']"
        then: [T: "astérisque"]                     #  0x2a	(en: 'star', DeepL translation)
        else: [T: "fois"]                 	        #  0x2a	(en: 'times')
 - "+": [T: "plus"]                             	#  0x2b	(MathPlayer: 'pluce')
 - ",":                                         	#  0x2c
    # the following deals with the interaction of "," with "…" which sometimes wants the ',' to be silent
    # that this test is here and not with "…" is not ideal, but seems simplest
     test:
        if:
            - "$SpeechStyle != 'ClearSpeak' or $ClearSpeak_Ellipses = 'Auto' or "
               # must be ClearSpeak and $ClearSpeak_Ellipses = 'AndSoOn'
               # speak "comma" when not adjacent to '…'
            - "( following-sibling::*[1][text()!= '…'] and preceding-sibling::*[1][text()!='…']  ) or "
               # except if expression starts with '…'
            - "../*[1][.='…'] "
        then:
        - T: "virgule"                            	#  	(en: 'comma')
        - test:
            if: "$Verbosity != Terse"
            then: [pause: short]
        # else silent

 - "-": [T: "moins"]                            	#  0x2d	(en: 'minus')
 - ".":                                         	#  0x2e
    - test:
        if: "parent::*[1][self::m:mn]"
        then: [T: "point"]                      	# 	(DeepL translation)
        else: [T: "point"]                      	# 	(en: 'dot')
 - "/":                                         	#  0x2f
    - test:
        if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')]"
        then: [T: "barre oblique"]              	#  0x2f	(en: 'slash', DeepL translation)
        else: [T: "divisé par"]              	    #  0x2f	(en: 'divided by')

 - ":": [T: "deux points"]                      	#  0x3a	(en: 'colon')
 - ";": [T: "point virgule"]                    	#  0x3b	(en: 'semicolon')
 - "<":                                         	#  0x3c
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "inférieur à"                         	# 	(en: 'less than')
 - "=":                                         	#  0x3d
    - test: 
        if: "$Verbosity!='Terse'"
        then: [T: "est égal à"]                 	# 	(en: 'is equal to', DeepL translation)
        else: [T: "égale"]                      	# 	(en: 'equals')

 - ">":                                         	#  0x3e
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "supérieur à"                         	# 	(en: 'greater than')
 - "?": [T: "point d'interrogation"]            	#  0x3f	(en: 'question mark')
 - "@": [T: "arobase"]                          	#  0x40	(en: 'at sign')
 - "[":                                         	#  0x5b
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then: [T: "crochet ouvrant"]         	    # 	(en: 'open bracket')
        else: [T: "crochet gauche"]             	# 	(en: 'left bracket', MathPlayer: 'crochet ouvrant', DeepL: 'parenthèse gauche')
 - "\\": [T: "crochet gauche"]                  	#  0x5c	(en: 'back slash', MathPlayer: 'crochet ouvrant', DeepL: 'barre oblique arrière')
 - "]":                                         	#  0x5d
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then: [T: "crochet fermant"]          	    # 	(en: 'close bracket')
        else: [T: "crochet droit"]              	# 	(en: 'right bracket', MathPlayer: 'crochet fermant', DeepL: 'parenthèse droite')
 - "^":                                         	#  0x5e
    - test:
        if: "parent::m:modified-variable or parent::m:mover"
        then: [T: "accent circonflexe"]             # 	(en: 'hat')
        else: [T: "accent circonflexe"]             # 	(en: 'caret')
 - "_": [T: "tiret bas"]                        	#  0x5f	(en: 'under bar')
 - "`": [T: "accent grave"]                     	#  0x60	(en: 'grave')
 - "{":                                         	#  0x7b
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then: [T: "accolade ouverte"]           	# 	(en: 'open brace', DeepL translation)
        else: [T: "accolade gauche"]            	# 	(en: 'left brace', MathPlayer: 'accolade ouvrante')
 - "|":                                         	#  0x7c
    # note: for ClearSpeak and SimpleSpeak, "|" inside of sets is handled at the mrow level, same for 'sets'
     - with:
        variables: [DefaultToGiven: "count(preceding-sibling::*)=1 and count(following-sibling::*)=1 and ../../../*[1][.='P']"]	#  P(A|B)
        replace:
        - test:
            - if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')]"
              then: [T: "ligne verticale"]      	# 	(en: 'vertical line', DeepL translation)
            - else_if: "$SpeechStyle != 'ClearSpeak'"
              then_test:
                - if: "$DefaultToGiven"
                  then: [T: "sachant"]            	# 	(en: 'given', DeepL translation)
                - else_if: "preceding-sibling::*[1][self::m:mn and not(contains(., $DecimalSeparators))] and 
                            following-sibling::*[1][self::m:mn and not(contains(., $DecimalSeparators))]"
                  then: [T: "divise"]           	# 	(en: 'divides', DeepL translation)
                  else: [T: "ligne verticale"]  	# 	(en: 'vertical line')
            - else_if: "not(preceding-sibling::*) or not(following-sibling::*)"
              then: [T: "ligne verticale"]      	# 	(en: 'vertical line', DeepL translation)
            - else_if: "$ClearSpeak_VerticalLine = 'SuchThat'"
              then: [T: "tel que"]              	# 	(en: 'such that', DeepL translation)
            - else_if: "$ClearSpeak_VerticalLine = 'Given' or $DefaultToGiven"
              then: [T: "sachant"]                	# 	(en: 'given', DeepL translation)
            - else: [T: "divise"]      	            # 	(en: 'divides')

 - "}":                                         	#  0x7d
    - test:
        if: $SpeechStyle = 'ClearSpeak' or $SpeechStyle = 'SimpleSpeak'
        then: [T: "accolade fermée"]                # 	(en: 'close brace')
        else: [T: "accolade droite"]            	# 	(en: 'right brace', MathPlayer: 'accolade fermante')

 - "~": [T: "tilde"]                            	#  0x7e
 - " ":                                         	#  0xa0
    - test:
        # could be mtext in mtd or mtext in an mrow that is a concatenation of mtd's. Is there a better solution?
        if: "@data-empty-in-2D and not(ancestor::*[self::m:piecewise or self::m:system-of-equations or self::m:lines])"
        then: [T: "vide"]                       	#  want to say something for fraction (etc) with empty child	(en: 'empty', DeepL translation)
        else: [T: ""]                            

 - "¬": [T: "non"]                         	        #  0xac	(en: 'not')
 - "°": [T: "degrés"]                           	#  0xb0	(en: 'degrees')
 - "±": [T: "plus ou moins"]                    	#  0xb1	(en: 'plus or minus')
 - "´": [T: "accent aigu"]                      	#  0xb4	(en: 'acute')
 - "·":                                         	#  0xB7
    - test:
        if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')] or not($SpeechStyle = 'ClearSpeak' and $ClearSpeak_MultSymbolDot = 'Auto')"
        then: [T: "point"]                      	# 	(en: 'dot', DeepL translation)
        else: [T: "fois"]               	        # 	(en: 'times')
 - "×":                                         	#  0xd7
    - test:
        if: "$SpeechStyle = 'ClearSpeak'"
        then_test:
        - if: "$ClearSpeak_MultSymbolX = 'Auto'"
          then: [T: "fois"]                     	# 	(en: 'times', DeepL translation)
        - else_if: "$ClearSpeak_MultSymbolX = 'By'"
          then: [T: "par"]                      	# 	(en: 'by', DeepL translation)
          else: [T: "multiplié par"]            	# 	(en: 'cross')
        else_test:
            if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')]"
            then: [T: "croix"]              # 	(en: 'cross', DeepL translation)
            else: [T: "multiplié par"]          	# 	(en: 'times')

 - "÷": [T: "divisé par"]                       	#  0xf7	(en: 'divided by')
 - "̀": [T: "diacritique accent grave"]         	#  0x300	(en: 'grave accent embellishment', DeepL: 'accent grave embellissement')
 - "́": [T: "diacritique accent aigu"]          	#  0x301	(en: 'acute accent embellishment', DeepL: 'accent aigu')
 - "̂": [T: "diacritique accent circonflexe"]   	#  0x302	(en: 'circumflex accent embellishment', DeepL: 'accent circonflexe fioriture')
 - "̃": [T: "diacritique tilde"]                	#  0x303	(en: 'tilde embellishment', DeepL: 'tilde embellissement')
 - "̄": [T: "diacritique macron"]               	#  0x304	(en: 'macron embellishment', DeepL: 'emblème macron')
 - "̅": [T: "diacritique tiret haut"]           	#  0x305	(en: 'overbar embellishment', DeepL: 'embellissement de la barre supérieure')
 - "̆": [T: "diacritique brève"]                	#  0x306	(en: 'breve', DeepL: 'breve')
 - "̇": [T: "diacritique point en chef"]        	#  0x307	(en: 'dot above embellishment', DeepL: 'point au-dessus de la fioriture')

   # Note: ClearSpeak has pref TriangleSymbol for "Δ", but that is wrong
 - "Α-Ω": 
    - test: 
        if: "$CapitalLetters_Beep"
        then:
        - audio:
            value: "beep.mp4"
            replace: []
    - pitch:
        value: "$CapitalLetters_Pitch"
        # note: processing of ranges converts '.' into the character, so it needs to be in quotes below
        replace: [SPELL: "translate('.', 'ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡ΢ΣΤΥΦΧΨΩ', 'αβγδεζηθικλμνξοπρςστυφχψω')"]
    - test: 
        if: "$CapitalLetters_UseWord"
        then_test:
          if: "$SpeechOverrides_CapitalLetters = ''"
          then_test:
            if: "$Impairment = 'Blindness'"
            then: [T: "majuscule"]              	# 	(en: 'cap', DeepL translation)
          else: [x: "$SpeechOverrides_CapitalLetters"]

 - "α": [T: "alpha"]                            	#  0x3b1
 - "β": [T: "bêta"]                             	#  0x3b2	(en: 'beta')
 - "γ": [T: "gamma"]                            	#  0x3b3
 - "δ": [T: "delta"]                            	#  0x3b4
 - "ε": [T: "epsilon"]                          	#  0x3b5
 - "ζ": [T: "zêta"]                             	#  0x3b6	(en: 'zeta')
 - "η": [T: "êta"]                              	#  0x3b7	(en: 'eta', DeepL: 'eta')
 - "θ": [T: "thêta"]                            	#  0x3b8	(en: 'theta')
 - "ι": [T: "iota"]                             	#  0x3b9
 - "κ": [T: "kappa"]                            	#  0x3ba
 - "λ": [T: "lambda"]                           	#  0x3bb
 - "μ": [T: "mû"]                               	#  0x3bc	(en: 'mu', DeepL: 'mu')
 - "ν": [T: "nû"]                               	#  0x3bd	(en: 'nu', DeepL: 'nu')
 - "ξ": [T: "xi"]                               	#  0x3be	(en: 'zai', DeepL: 'zai')
 - "ο": [T: "omicron"]                          	#  0x3bf
 - "π": [T: "pi"]                               	#  0x3c0
 - "ρ": [T: "rhô"]                              	#  0x3c1
 - "ς": [T: "sigma final"]                      	#  0x3c2	(en: 'final sigma')
 - "σ": [T: "sigma"]                            	#  0x3c3
 - "τ": [T: "tau"]                              	#  0x3c4
 - "υ": [T: "upsilon"]                          	#  0x3c5
 - "φ": [T: "phi"]                              	#  0x3c6
 - "χ": [T: "chi"]                              	#  0x3c7
 - "ψ": [T: "psi"]                              	#  0x3c8
 - "ω": [T: "oméga"]                            	#  0x3c9	(en: 'omega')
 - "ϕ": [T: "phi"]                        	        #  0x3d5	(en: 'phi', DeepL: 'phi')
 - "ϖ": [T: "pi"]                        	        #  0x3d6	(en: 'pi', DeepL: 'pi')
 - "ϵ": [T: "epsilon"]                          	#  0x3f5
 - "϶": [T: "epsilon inversé"]         	            #  0x3f6	(en: 'reversed epsilon')

 - "–": [T: "tirait demi-cadratin"]          	    #  0x2013	(en: 'en dash')
 - "—": [T: "tiret cadratin"]                  	    #  0x2014	(en: 'em dash')
 - "―": [T: "barre horizontalle"]               	#  0x2015	(en: 'horizontal bar')
 - "‖": [T: "double ligne verticale"]           	#  0x2016	(en: 'double vertical line')
 - "…":                                         	#  0x2026
    test:
        if:
            - "$SpeechStyle != 'ClearSpeak' or $ClearSpeak_Ellipses = 'Auto' or"
               # must be ClearSpeak and $ClearSpeak_Ellipses = 'AndSoOn'
               # speak '…' as 'and so on...' unless expr starts with '…'
            - "../*[1][.='…']"
        then: [T: "point point point"]          	# 	(en: 'dot dot dot', DeepL translation)
        else_test:                              	#  must have $ClearSpeak_Ellipses = 'AndSoOn'
            if: "count(following-sibling::*) = 0"
            then: [T: "et ainsi de suite"]      	# 	(en: 'and so on', DeepL translation)
            else: [T: "et ainsi de suite jusqu'à"]   	# 	(en: 'and so on up to')

 - "⁡":                                         	#  0x2061
    - test:
        # skip saying "of" when Terse and a trig function, when it is a shape (does this happen?), or we are in :literal mode
        if: "not(
              ( $Verbosity='Terse' or ($SpeechStyle = 'ClearSpeak' and IsNode(following-sibling::*[1],'simple')) and
                preceding-sibling::*[1][IfThenElse($SpeechStyle='ClearSpeak',
                                                   IsInDefinition(., 'ClearSpeakTrigFunctionNames'),
                                                   IsInDefinition(., 'TrigFunctionNames') )]
              ) or
              preceding-sibling::*[1][IsInDefinition(., 'GeometryShapes')] or
              (@data-changed='added' and ancestor-or-self::*[contains(@data-intent-property, ':literal:')])
            )"
        then: [T: "de"]                            # 	(en: 'of', DeepL translation)
 - "⁢": [T: ""]                                 	#  0x2062
 - "⁣": [T: ""]                                 	#  0x2063
 - "⁤": [T: "et"]                             	    #  0x2064	(en: 'and', DeepL: 'et')
 - "′": [T: "prime"]                               #  0x2032
 - "″": [T: "double prime"]                        #  0x2033
 - "‴": [T: "triple prime"]                        #  0x2034

 - "ℂℕℚℝℤ":                                     	#  here we rely on this running through the table again to speak "cap xxx"
    - T: "triple prime"                         	# 	(en: 'double-struck')
    - SPELL: "translate('.', 'ℂℕℚℝℤ', 'CNQRZ')"

 - "℃": [T: "degré celsius"]                    	#  0x2103	(en: 'degrees celsius', DeepL: 'degrés celsius')
 - "℉": [T: "degré fahrenheit"]                 	#  0x2109	(en: 'degrees fahrenheit', DeepL: 'degrés fahrenheit')
 - "ℋℛℓ":                                       	#  0x210b
    - T: "script"                     	# 	(en: 'script', DeepL: 'script')
    - SPELL: "translate('.', 'ℋℛℓ', 'HRl')"
 - "ℎ": [T: "constante de planck"]              	#  0x210e	(en: 'planck constant')
 - "ℜ":                                         	#  0x211c
    - T: "r gothique majuscule"                 	# 	(en: 'fraktur', DeepL: 'fraktur')
    - SPELL: "'R'"

 - "Ω": [T: "ohm"]                              	#  0x2126	(en: 'ohms')
 - "K": [T: "degré kelvin"]                     	#  0x212a	(en: 'kelvin')
 - "Å": [T: "angstroms"]                        	#  0x212b
 - "ⅆⅇⅈⅉ":                                      	#  0x2146-9
    - T: "angstroms"                            	# 	(en: 'double-struck italic')
    - SPELL: "translate('.', 'ⅆⅇⅈⅉ', 'deij')"

 - "←": [T: "flèche vers la gauche"]            	#  0x2190	(en: 'leftwards arrow', SRE: 'flèche gauche')
 - "↑": [T: "flèche vers le haut"]              	#  0x2191	(en: 'upwards arrow')
 - "→":                                         	#  0x2192
     - test:
        if: "ancestor::*[2][self::m:limit]"
        then: [T: "approche"]                   	# 	(en: 'approaches', DeepL translation)
        else: [T: "flèche vers la droite"]          # 	(en: 'right arrow', MathPlayer: 'flèche vers la droite')

 - "↓": [T: "flèche vers le bas"]               	#  0x2193	(en: 'downwards arrow')
 - "⇒": [T: "double flèche vers la droite"]        #  0x21d2	(en: 'rightwards double arrow', SRE: 'double flèche droite')
 - "∀": [T: "pour tous"]                        	#  0x2200	(en: 'for all')
 - "∂":                                         	#  0x2202
     - test: 
         if: "$Verbosity='Terse'"
         then: [T: "partiel"]                   	# 	(en: 'partial', DeepL translation)
         else: [T: "dérivée partielle"]         	# 	(en: 'partial derivative')
 - "∃": [T: "il existe"]                        	#  0x2203	(en: 'there exists')
 - "∄": [T: "il n'existe pas"]                  	#  0x2204	(en: 'there does not exist')
 - "∅": [T: "ensemble vide"]                    	#  0x2205	(en: 'empty set')
 - "∆":                                         	#  0x2206
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "le"]                        	# 	(en: 'the', DeepL translation)
     - T: "laplacien de"                           	# 	(en: 'laplacian of')
 - "∈":                                         	#  0x2208
     - test:
        if: "$SpeechStyle != 'ClearSpeak'"
        then:
        - test:
            if: "$Verbosity!='Terse' and not(ancestor::*[self::m:set])"	#  "the set x is an element of ..." sounds bad"
            then: [T: "est"]                    	# 	(en: 'is', DeepL translation)
        - T: "un élément de"                     	# 	(en: 'an element of')
        # Several options for speaking elements in ClearSpeak -- they split between being inside a set or not and then the option
        else_test:
            if: "../../self::m:set or ../../../self::m:set"	#  inside a set
            then_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "dans"]                 	# 	(en: 'in', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "membre de"]          	# 	(en: 'member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "élément de"]         	# 	(en: 'element of', DeepL translation)
              - else: [T: "appartenant à"]       	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'belonging to')
            else_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "est membre de"]      	# 	(en: 'is a member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "est un élément de"]  	# 	(en: 'is an element of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "est dans"]           	# 	(en: 'is in', DeepL translation)
              - else: [T: "appartient à"]       	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'belongs to')
 - "∉":                                         	#  0x2209
    # rule is identical to 0x2208
     - test:
        if: "$SpeechStyle != 'ClearSpeak'"
        then:
        # - test: 
        #     if: "$Verbosity!='Terse'"
        #     then: [T: "est"]                    	# 	(en: 'is', DeepL translation)
        - T: "n'appartient pas à"               	# 	(en: 'not an element of')
        # Several options for speaking elements in ClearSpeak -- they split between being inside a set or not and then the option
        else_test:
            if: "../../self::m:set or ../../../self::m:set"	#  inside a set
            then_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "pas dans"]           	# 	(en: 'not in', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "n'est pas membre de"]	# 	(en: 'not member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "n'est pas un élément de"]  	# 	(en: 'not element of', DeepL translation)
              - else: [T: "n'appartient pas à"] 	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'not belonging to')
            else_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "n'est pas membre de"]	# 	(en: 'is not a member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "n'est pas un élément de"]	# 	(en: 'is not an element of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "n'est pas dans"]     	# 	(en: 'is not in', DeepL translation)
              - else: [T: "n'appartient pas à"] 	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'does not belong to')
 - "∊":                                         	#  0x220a
     - test:
        if: "$SpeechStyle != 'ClearSpeak'"
        then:
        - test: 
            if: "$Verbosity!='Terse' and not(ancestor::*[self::m:set])"	#  "the set x is an element of ..." sounds bad"
            then: [T: "est"]                    	# 	(en: 'is', DeepL translation)
        - T: "appartient à"                     	# 	(en: 'an element of')
        # Several options for speaking elements in ClearSpeak -- they split between being inside a set or not and then the option
        else_test:
            if: "../../self::m:set or ../../../self::m:set"	#  inside a set
            then_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "en"]                 	# 	(en: 'in', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "membre de"]          	# 	(en: 'member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "élément de"]         	# 	(en: 'element of', DeepL translation)
              - else: [T: "appartient à"]       	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'belonging to')
            else_test:
              - if: $ClearSpeak_SetMemberSymbol = 'Auto' or $ClearSpeak_SetMemberSymbol = 'Member'
                then: [T: "est membre de"]      	# 	(en: 'is a member of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'Element'
                then: [T: "est un élément de"]  	# 	(en: 'is an element of', DeepL translation)
              - else_if: $ClearSpeak_SetMemberSymbol = 'In'
                then: [T: "est dans"]           	# 	(en: 'is in', DeepL translation)
              - else: [T: "appartient à"]       	#  $ClearSpeak_SetMemberSymbol = 'Belongs'	(en: 'belongs to')
 - "∏": [T: "produit"]                          	#  0x220f	(en: 'product')
 - "∐": [T: "coproduit"]                        	#  0x2210	(en: 'co-product')
 - "∑": [T: "sommation"]                        	#  0x2211	(en: 'sum')
 - "−": [T: "moins"]                            	#  0x2212	(en: 'minus')
 - "∓": [T: "moins ou plus"]                    	#  0x2213	(en: 'minus or plus', MathPlayer: 'moins-ou-plus')
 - "∗": [T: "fois"]             	                #  0x2217	(en: 'times')
 - "∘": [T: "composé avec"]                   	    #  0x2218	(en: 'composed with')
 - "√":                                         	#  0x221a
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "la"]                        	# 	(en: 'the', DeepL translation)
     - T: "racine carrée"                       	# 	(en: 'square root of')
 - "∝":                                         	#  0x221d
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "proportionnel à"                     	# 	(en: 'proportional to')
 - "∞": [T: "infini"]                           	#  0x221e	(en: 'infinity')
 - "∟": [T: "angle droit"]                      	#  0x221f	(en: 'right angle')
 - "∠": [T: "angle"]                            	#  0x2220
 - "∡": [T: "angle mesuré"]                     	#  0x2221	(en: 'measured angle')
 - "∣": [T: "est un diviseur de"]               	#  0x2223	(en: 'divides')
 - "∤": [T: "n'est pas un diviseur de"]         	#  0x2224	(en: 'does not divide')
 - "∥":                                         	#  0x2225
     - test:
         if: "ancestor-or-self::*[contains(@data-intent-property, ':literal:')]"
         then: [T: "double ligne verticale"]    	# 	(en: 'double vertical line', DeepL translation)
         else:
         - test:
              if: "$Verbosity!='Terse'"
              then: [T: "est"]                  	# 	(en: 'is', DeepL translation)
         - T: "parallèle à"                     	# 	(en: 'parallel to')
 - "∦":                                         	#  0x2226
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "n'est"]                       	# 	(en: 'is', DeepL translation)
     - T: "pas parallèle à"                     	# 	(en: 'not parallel to')
 - "∧": [T: "et logique"]                       	#  0x2227	(en: 'and')
 - "∨": [T: "ou logique"]                       	#  0x2228	(en: 'or')
 - "∩": [T: "intersection"]                     	#  0x2229
 - "∪": [T: "\uF8FEunion"]                            	#  0x222a
 - "∫": [T: "\uF8FEintégrale"]                        	#  0x222b	(en: 'integral')
 - "∬": [T: "\uF8FEintégrale double"]                 	#  0x222c	(en: 'double integral')
 - "∭": [T: "\uF8FEintégrale triple"]                 	#  0x222d	(en: 'triple integral')
 - "∮": [T: "\uF8FEintégrale de contour"]             	#  0x222e	(en: 'contour integral')
 - "∶":                                         	#  0x2236
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "rapport"                             	# 	(en: 'to')
 - "∷": [T: "proportion"]                       	#  0x2237	(en: 'as')
 - "∼": [T: "varie avec"]                  	        #  0x223c	(en: 'varies with')
 - "∽": [T: "tilde renversé"]         	            #  0x223d	(en: 'reversed tilde')
 - "∾":                                         	#  0x223e
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "s couché renversé"                   	# 	(en: 'most positive')
 - "∿": [T: "sinusoïde"]                        	#  0x223f	(en: 'sine wave')
 - "≠":                                         	#  0x2260
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "n'est"]                       	# 	(en: 'is', DeepL translation)
     - T: "pas égal à"                          	# 	(en: 'not equal to')
 - "≡":                                         	#  0x2261
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "identique à"                         	# 	(en: 'identical to')
 - "≤":                                         	#  0x2264
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "plus petit ou égal à"                	# 	(en: 'less than or equal to')
 - "≥":                                         	#  0x2265
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est"]                       	# 	(en: 'is', DeepL translation)
     - T: "plus grand ou égal à"                	# 	(en: 'greater than or equal to')
 - "≦": [T: "plus petit que par-dessus égal à"] 	#  0x2266	(en: 'less than over equal to', MathPlayer: 'plus petit que par-dessus égal à', DeepL: 'inférieur à supérieur à égal à')
 - "≧": [T: "plus grand que par-dessus égal à"] 	#  0x2267	(en: 'greater than over equal to', MathPlayer: 'plus grand que par-dessus égal à', DeepL: 'supérieur à égal à')
 - "≺": [T: "précède"]                          	#  0x227a	(en: 'precedes')
 - "≻": [T: "suit"]                             	#  0x227b	(en: 'succeeds')
 - "⊂":                                         	#  0x2282
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est un"]                    	# 	(en: 'is a', DeepL translation)
     - T: "sous-ensemble de"                    	# 	(en: 'subset of', SRE: 'sous ensemble de')
 - "⊃":                                         	#  0x2283
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est un"]                    	# 	(en: 'is a', DeepL translation)
     - T: "sur-ensemble de"                     	# 	(en: 'superset of', SRE: 'sur ensemble de')
 - "⊄":                                         	#  0x2284
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "n'est"]                       	# 	(en: 'is', DeepL translation)
     - T: "pas un sous-ensemble de"             	# 	(en: 'not a subset of', SRE: 'pas un sous ensemble de')
 - "⊅":                                         	#  0x2285
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "n'est"]                       	# 	(en: 'is', DeepL translation)
     - T: "pas un sur ensemble de"              	# 	(en: 'not a superset of', MathPlayer: 'pas un sur-ensemble de', DeepL: 'n'est pas un super-ensemble de')
 - "⊆":                                         	#  0x2286
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est un"]                    	# 	(en: 'is a', DeepL translation)
     - T: "sous ensemble ou égal à"             	# 	(en: 'subset of or equal to', MathPlayer: 'sous-ensemble ou égal à', DeepL: 'sous-ensemble de ou égal à')
 - "⊇":                                         	#  0x2287
     - test: 
         if: "$Verbosity!='Terse'"
         then: [T: "est un"]                    	# 	(en: 'is a', DeepL translation)
     - T: "sur ensemble ou égal à"              	# 	(en: 'superset of or equal to', MathPlayer: 'sur-ensemble ou égal à', DeepL: 'sur-ensemble de ou égal à')
