code: def match_score(self, supported: 'Language') -> int:
          
          if supported == self:
              return 100
  
          desired_complete = self.prefer_macrolanguage().maximize()
          supported_complete = supported.prefer_macrolanguage().maximize()
  
          desired_triple = (desired_complete.language, desired_complete.script, desired_complete.region)
          supported_triple = (supported_complete.language, supported_complete.script, supported_complete.region)
  
          return 100 - raw_distance(desired_triple, supported_triple)
docs: Suppose that `self` is the language that the user desires, and
          `supported` is a language that is actually supported. This method
          returns a number from 0 to 100 indicating how similar the supported
          language is (higher numbers are better). This is not a symmetric
          relation.
  
          The algorithm here is described (badly) in a Unicode technical report
          at http://unicode.org/reports/tr35/#LanguageMatching. If you find these
          results bothersome, take it up with Unicode, unless it's particular
          tweaks we implemented such as macrolanguage matching.
  
          See :func:`tag_match_score` for a function that works on strings,
          instead of requiring you to instantiate Language objects first.
          Further documentation and examples appear with that function.