version: '0.1.35'
update_url: 'https://raw.github.com/commenthol/ua-parser2/master/regexes.yaml'

#### Browser ####
user_agent_parsers:

  ### iOS / OSX Applications
  - regex: '\b(CFNetwork|CaptiveNetworkSupport)'
    group:
    - regex: '^((?:(?! CFNetwork|/).)+)(?:/(\d+)(?:\.([a-z\d]+))*|.*)? CFNetwork/.*'
      type: 'app'
    - regex: '(CFNetwork)(?:/(\d+)(?:\.(\d+))+)?'
      family: 'CFNetwork'
      type: 'app'
    - regex: '(CaptiveNetworkSupport)-(\d+)'
      type: 'app'

  #### Bots ####
  - regex: '(@|bot|dig|JNLP|NING|seek|Xenu|crawl|health|checker|scope|lycos|slurp|sitecon|teoma|Reaper|faviconGenieo|google|larbin|pompos|scrap|snappy|spider|vortex|zyborg|indexer|monitor|voyager|WhatWeb|WinHTTP|archiver|charlotte|http[^:]*?://|Retreiver|TLSProber|WordPress|BlogBridge|Squrl Java|Python-urllib|Apache-HttpClient|facebookexternalhit|PayPal|adbeat)'
    regex_flag: 'i'
    group:
      # Pingdom
      - regex: '(Pingdom.com_bot_version_)(\d+)\.(\d+)'
        family: 'PingdomBot'
        type: 'bot'
      # Google Plus
      - regex: 'Google.*/\+/web/snippet'
        family: 'GooglePlusBot'
        type: 'bot'
      # Add loadbalancer and health-checks
      - regex: '(ELB-HealthChecker|SiteScope)(?:[ /](\d+)(?:\.(\d+))?(?:\.(\d+))?)?'
        regex_flag: 'i'
        type: 'bot::healthcheck'
      # sort by length
      - regex: '(BoardReader Favicon Fetcher *|Comodo SSL Checker|Flamingo_SearchEngine|Google-HTTP-Java-Client|Peeplo Screenshot Bot|IlTrovatore(?:-Setaccio)?|Rackspace Monitoring|facebookexternalhit|Mediapartners-Google|PlantyNet_WebRobot|Daumoa(?:-feedfetcher)?|Innovazion Crawler|semanticdiscovery|Apache-HttpClient|Xenu(?:.s)? Link Sleuth|AppEngine-Google|InternetArchive|PagesInventory|archive.*?\.org_bot|1470\.net crawler|AdsBot-Google(?:-[a-z]+)?|fast-webcrawler|websitepulse checker|Google SketchUp|ConveraCrawler|dataparksearch|PaxleFramework|ObjectsSearch|8bo Crawler Bot|ZeBot_www.ze.bz|Yahoo[a-z]*Seeker|Catchpoint bot|FollowSite Bot|ThumbShotsBot|YottaaMonitor|Feed Seeker Bot|(?:[a-z]+-)?Googlebot(?:-[a-z]+)?|masidani_bot|Sogou \w+ Spider|ichiro(?:/mobile)?|http%20client|Python-urllib|Microsoft .*? Bot|Thumbshots\.ru|TheUsefulbot|Sogou \w+ Robot|robotgenius|BoardReader|msnbot(?:-media *)?|\b\w*favicon\w*\b|boitho.com-dc|Read%20Later|WASALive.Bot|BingPreview|HttpMonitor|LinkedInBot|MSIECrawler|netresearch|searchsight|Yahoo! Slurp|SiteCon|ScoutJet|PayPal IPN|BlogBridge|Checklinks|PagePeeker|TwitterBot|Linguee Bot|Mail\.RU_Bot|RedCarpet|A6-Indexer|Squrl Java|adbeat\.com|altavista|Altresium|charlotte|findlinks|Retreiver|TLSProber|WordPress|NewsGator[^/]*|LesnikBot|archiver|Votay bot|teoma(?!bar)?|archiver|blitzbot|clumboot|heritrix|Icarus6j|IconSurf|InfuzApp|mogimogi|NerdyBot|Netvibes|WebThumb|IP2[a-z]+Bot|voila(?:bot)?|Lite Bot|Riddler|Orbiter|\bYeti(?:-[a-z]+)?|Yandex\w+|^voyager|bingbot|furlbot|gigabot|openbot|polybot|Riddler|scooter|scrubby|seekbot|URL2PNG|WhatWeb|WinHTTP|ZooShot|BotSeer|mozDex|Reaper|^vortex|DeuSu|Genieo|GomezA|holmes|Kraken|Kurzor|larbin|m65bot|msrbot|pompos|Scrapy|snappy|speedy|ZyBorg|Wotbox|^Nutch[^/]*|Argus|htdig|Llaut|lycos|Slurp|jbot\b|50\.nu|WIRE|^NING|JNLP|^zao|baidu[a-z]*(?:spider|Mobaider)|(?:[a-z\.\u0027]+[ _-]){0,3}[a-z_]*(?:crawler|crawl|scraper|spider|indexer|webbot|robot\b|(?:(?!cubot)[\w-]{2})bot\b| bot(?=@)\b)|[^ \/]\bbot\b)(?:[ /-](\d+)(?:\.(\d+))?(?:\.(\d+))?)?'
        regex_flag: 'i'
        type: 'bot'

  ### iOS / OSX Applications
  - regex: '\b(iPhone|iPad|iPod)'
    group:
      - regex: '^([^/]+)/(\d+)(?:\.(\d+))+ \((?:iPhone|iPad|iPod); iOS [0-9\.]+; Scale/[0-9\.]+\)'
        type: 'app'
      - regex: '^([^/]+)/(\d+)(?:\.(\d+))+ iOS/[0-9\.]+ model/(?:iPhone|iPad|iPod)'
        type: 'app'

  ### Mail
  - regex: '\b(Thunderbird|Icedove|Shredder|Spicebird|Lotus-Notes|Airmail|Lightning|MSOffice|Outlook|Barca|Bat|(?:Macintosh.* AppleWebKit|MailBar))'

    group:
      # Outlook 2007
      - regex: 'Microsoft Office Outlook 12\.\d+\.\d+|MSOffice 12'
        family: 'Outlook'
        v1: '2007'
        type: 'mail'
      # Outlook 2010
      - regex: 'Microsoft Outlook 14\.\d+\.\d+|MSOffice 14'
        family: 'Outlook'
        v1: '2010'
        type: 'mail'
      # Outlook 2013
      - regex: 'Microsoft Outlook 15\.\d+\.\d+'
        family: 'Outlook'
        v1: '2013'
        type: 'mail'
      # Outlook 2016
      - regex: 'Microsoft Outlook (?:Mail )?16\.\d+\.\d+'
        family: 'Outlook'
        v1: '2016'
        type: 'mail'
      # Windows Live Mail
      - regex: 'Outlook-Express\/7\.0.*'
        family: 'Windows Live Mail'
        type: 'mail'
      # Other Mail Agents
      - regex: '(Lotus-Notes|MailBar|Microsoft Outlook|Outlook-Express|Barca(?:Pro)?|Postbox|The Bat!(?: Voyager)?)(?:[/ ](\d+)(?:\.(\d+))?)?'
        type: 'mail'
      # Apple Air Mail
      - regex: '(Airmail) (\d+)\.(\d+)(?:\.(\d+))?'
        type: 'mail'
      - regex: '(Shredder|Spicebird)/(\d+)\.(\d+)(?:\.(\d+(?:pre)?))?'
        type: 'mail'
      # Apple Mail
      - regex: '^Mozilla\/5\.0 \(.* Mac OS X.*\(KHTML, like Gecko\)(?: Mobile\/[\S]*)?$'
        family: 'Apple Mail'
        type: 'mail'
      # Thunderbird
      - regex: '(Thunderbird|Icedove)/(\d+)\.(\d+)(?:\.(\d+(?:pre)?))?'
        family: 'Thunderbird'
        type: 'mail'
      # Lightning
      - regex: '\b(Lightning)/(\d+)(?:\.(\d+)(?:\.?([ab]?\d+[a-z]*))?)?'
        type: 'mail'

  # Feedreader
  - regex: '\b(Digg Feed Fetcher|AideRSS|Akregator|Apple-PubSub|FeedDa?emon|Feeddler|Feedreader|JetBrains Omea Reader|Liferea|NetNewsWire|NewsBlur|newsbeuter|Pulp|ReadKit|(?:RSS|Rss)Bandit|RssBar|RSS Junkie|RSS Menu|RSSOwl|SimplePie|SimpleRSS|Tiny Tiny RSS|UniversalFeedParser|Wizz RSS News Reader|Windows-RSS-Platform)(?:[ /](\d+)(?:\.(\d+))?(?:\.(\d+))?)?'
    type: 'feedreader'

  # mediaplayers
  - regex: '\b(Banshee|Clementine|MediaMonkey)(?:[ /](\d+)(?:\.(\d+)(?:\.(\d)+)?)?)?'
    type: 'mediaplayer'

  - regex: '\b(Instacast|iTunes(?:-iP\w+(?:-\w+)?)?|FlyCast|Nightingale|Songbird|Spotify|SubStream|vlc|Windows-Media-Player(?:-\w+)?|XBMC)\b(?:[ /]?(\d+)(?:\.(\d+)(?:\.(\d)+)?)?)?'
    type: 'mediaplayer'

  - regex: '(QuickTime)(?:(?:(?:.+qtver=)|(?:(?: E-)?[\./]))(\d+)(?:\.(\d+)(?:\.(\d)+)?)?)?'
    type: 'mediaplayer'

  # social networks
  - regex: 'Pinterest|\[FB'
    group:
      # Facebook
      - regex: '\[FB.*;(FB(?:AV|Version))/(\d+)(?:\.(\d+)(?:\.(\d)+)?)?'
        family: 'Facebook'
        type: 'app'
      # Pinterest
      - regex: '\[(Pinterest)/[^\]]+\]'
      - regex: '(Pinterest)(?: for Android(?: Tablet)?)?/(\d+)(?:\.(\d+)(?:\.(\d)+)?)?'
        type: 'app'

  #### SPECIAL CASES TOP ####

  # Gecko group
  - regex: 'Gecko|Treco|FxiOS'
    group:
      # Browsers using Gecko; must go before Firefox
      - regex: 'Mozilla.*\b(Beonex|Camino|Chimera|CometBird|Firebird(?: Browser)?|Fireweb Navigator|Flock|IceDragon|SailfishBrowser|SeaMonkey)/(\d+)(?:\.(\d+)(?:\.?([ab]?\d+[a-z]*))?)?'

      # Firefox
      - regex: '(Fennec)/(\d+)\.(\d+)\.?(pre|[ab]?\d+[a-z]*)'
        family: 'Firefox Mobile'
      - regex: '(?:Mobile[:;]|Tablet;).*(Firefox)/(\d+)\.(\d+)'
        family: 'Firefox Mobile'
      - regex: '\b(BonEcho|GranParadiso|Lorentz|Minefield|Namoroka|Pale[Mm]oon|Shiretoko)/(\d+)(?:\.(\d+)(?:\.?([ab]?\d+[a-z]*))?)?'
        family: 'Firefox ($1)'
      - regex: '(Firefox)/(\d+)\.(\d+)(a\d+[a-z]*)'
        family: 'Firefox Alpha'
      - regex: '(Firefox)/(\d+)\.(\d+)(b\d+[a-z]*)'
        family: 'Firefox Beta'
      - regex: '(Firefox)-(?:\d+\.\d+)?/(\d+)\.(\d+)(a\d+[a-z]*)'
        family: 'Firefox Alpha'
      - regex: '(Firefox)-(?:\d+\.\d+)?/(\d+)\.(\d+)(b\d+[a-z]*)'
        family: 'Firefox Beta'
      - regex: '(Firefox).*Tablet browser (\d+)\.(\d+)\.(\d+)'
        family: 'MicroB'
      - regex: '(MozillaDeveloperPreview)/(\d+)\.(\d+)([ab]\d+[a-z]*)?'
      - regex: '(FxiOS)/(\d+)\.(\d+)(\.(\d+))?(\.(\d+))?'
        family: 'Firefox iOS'

      # Swiftfox
      - regex: '(Firefox)/(\d+)\.(\d+)\.(\d+(?:pre)?) \(Swiftfox\)'
        family: 'Swiftfox'
      - regex: '(Firefox)/(\d+)\.(\d+)([ab]\d+[a-z]*)? \(Swiftfox\)'
        family: 'Swiftfox'

  - regex: '(MyIBrow)/(\d+)\.(\d+)'
    family: 'My Internet Browser'

  # Opera group
  - regex: 'Opera|OPR|OPiOS|Coast'

    group:
      # Opera will stop at 9.80 and hide the real version in the Version string.
      # see: http://dev.opera.com/articles/view/opera-ua-string-changes/
      - regex: '(Opera Tablet).*Version/(\d+)\.(\d+)(?:\.(\d+))?'
      - regex: '(Opera Mini)(?:/att)?/(\d+)?(?:\.(\d+))?(?:\.(\d+))?'
      - regex: '(Opera)/.+Opera Mobi.+Version/(\d+)\.(\d+)'
        family: 'Opera Mobile'
      - regex: '(Opera)/(\d+)\.(\d+).+Opera Mobi'
        family: 'Opera Mobile'
      - regex: 'Opera Mobi.+(Opera)(?:\/|\s+)(\d+)\.(\d+)'
        family: 'Opera Mobile'
      - regex: 'Opera Mobi'
        family: 'Opera Mobile'
      - regex: '(Opera)/9.80.*Version/(\d+)\.(\d+)(?:\.(\d+))?'

      # Opera 14 for Android uses a WebKit render engine.
      - regex: '(?:Mobile Safari).*(OPR)/(\d+)\.(\d+)\.(\d+)'
        family: 'Opera Mobile'

      # Opera 15 for Desktop is similar to Chrome but includes an "OPR" Version string.
      - regex: '(?:Chrome).*(OPR)/(\d+)\.(\d+)\.(\d+)'
        family: 'Opera'

      # Opera Coast
      - regex: '(Coast)/(\d+).(\d+).(\d+)'
        family: 'Opera Coast'

      # Opera Mini for iOS (from version 8.0.0)
      - regex: '(OPiOS)/(\d+).(\d+).(\d+)'
        family: 'Opera Mini'

  # Palm WebOS looks a lot like Safari.
  - regex: '(hpw|web)OS/(\d+)\.(\d+)(?:\.(\d+))?'
    family: 'webOS Browser'

  # LuaKit has no version info.
  # ref: http://luakit.org/projects/luakit/
  - regex: '(luakit)'
    family: 'LuaKit'

  # Rekonq
  - regex: '(rekonq)(?:/(\d+)\.(\d+)\.?(\d+)? Safari)?'
    family: 'Rekonq'

  # Conkeror lowercase/uppercase
  # ref: http://conkeror.org/
  - regex: '([Cc]onkeror)/(\d+)\.(\d+)\.?(\d+)?'
    family: 'Conkeror'

  # catches lower case konqueror
  - regex: '([Kk]onqueror)/(\d+)\.(\d+)\.?(\d+)?'
    family: 'Konqueror'

  - regex: '(WeTab)-Browser'

  - regex: '(Comodo[ _]Dragon)/(\d+)\.(\d+)\.(\d+)'
    family: 'Comodo Dragon'

  - regex: '(Symphony) (\d+).(\d+)'

  - regex: '(Minimo)'

  # Yandex Browser
  - regex: '(YaBrowser)/(\d+)(?:\.(\d+)(?:\.(\d+))?)?'
    family: 'Yandex Browser'

  # PlayStation Vita should go before Amazon Silk
  - regex: '(PLAYSTATION 3.+WebKit|Nintendo 3DS|PlayStation Vita|AppleWebKit.+ NX)(?:/(\d+)\.(\d+)\.(\d+))?'
    family: 'NetFront NX'
  # Amazon Silk, should go before Chrome Mobile and Safari
  - regex: '(Silk)/(\d+)\.(\d+)(?:\.([0-9\-]+))?'
    family: 'Amazon Silk'

  - regex: '(Puffin|SamsungBrowser)/(\d+)\.(\d+)(?:\.(\d+))?'

  # Edge Mobile
  - regex: 'Windows Phone .*(Edge)/(\d+)\.(\d+)'
    family: 'Edge Mobile'

  # Chrome Mobile
  - regex: 'CrMo|CriOS|Chrome|chromeframe'
    group:
      - regex: '(CrMo)/(\d+)\.(\d+)\.(\d+)\.(\d+)'
        family: 'Chrome Mobile'
      - regex: '(CriOS)/(\d+)\.(\d+)\.(\d+)\.(\d+)'
        family: 'Chrome Mobile iOS'
      - regex: '(Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+) .*\bMobile\b'
        family: 'Chrome Mobile'
      - regex: '\bMobile\b.*(Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+)'
        family: 'Chrome Mobile'

      # Chrome Frame must come before MSIE.
      - regex: '(chromeframe)/(\d+)\.(\d+)\.(\d+)'
        family: 'Chrome Frame'

  # UC Browser
  - regex: '(UC ?Browser|UCBrowser|UCWEB)[ /]?(\d+)\.(\d+)\.(\d+)'
    family: 'UC Browser'

  # Tizen Browser (second case included in browser/major.minor regex)
  - regex: '(Tizen|SLP) Browser/(\d+)\.(\d+)'
    family: 'Tizen Browser'

  # Sogou Explorer 2.X
  - regex: '(SE 2\.X) MetaSr (\d+)\.(\d+)'
    family: 'Sogou Explorer'

  # Baidu Browsers (desktop spoofs chrome & IE, explorer is mobile)
  - regex: '(baidubrowser)[/\s](\d+)'
    family: 'Baidu Browser'
  - regex: '(FlyFlow)/(\d+)\.(\d+)'
    family: 'Baidu Explorer'

  #Baidu Spark
  - regex: '((?:BD)?Spark|BIDUBrowser)[ /](\d+)(?:\.(\d+))?'
    family: 'Baidu Spark'

  # QQ Browsers
  - regex: 'QQBrowser'

    group:
      - regex: '(MQQBrowser/Mini)(?:(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?'
        family: 'QQ Browser Mini'
      - regex: '(MQQBrowser)(?:/(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?'
        family: 'QQ Browser Mobile'
      - regex: '(QQBrowser)(?:/(\d+)(?:\.(\d+)\.(\d+)(?:\.(\d+))?)?)?'
        family: 'QQ Browser'

  # Mail.ru Amigo/Internet Browser (Chromium-based)
  - regex: '(Chrome)/(\d+)\.(\d+)\.(\d+).* MRCHROME'
    family: 'Mail.ru Chromium Browser'

  # AOL Browser (IE-based)
  - regex: '(AOL) (\d+)\.(\d+); AOLBuild (\d+)'

  # OmniWeb
  - regex: '(OmniWeb)/v?(\d+)(?:\.(\d+)(?:\.(\d+))?)?'

  # Netscape
  - regex: '\b(Navigator|Netscape6)/(\d+)(?:\.(\d+)(?:\.?([ab]?\d+[a-z]*))?)?'
    family: 'Netscape'


  # Windows 10 IE version uses "Edge" and "Chrome"
  - regex: '\b(Edge)/(\d+)\.(\d+)'
    family: 'Edge'

  # iOS Versions of Browsers
  - regex: '(Mercury|Puffin)/(\d{3,5})'

  # Browser/major_version.minor_version(.beta_version)
  - regex: '(Phoenix)/(\d+)(?:\.(\d+)(?:\.(\d+))?)?'
  - regex: '(Abrowser|AdobeAIR|amaya|Amiga-AWeb|AmigaVoyager|ANTFresco|ANTGalio|Arora|Bolt|BOLT|brave|Bunjalloo|Crazy Browser|Chromium|ChromePlus|CoolNovo|Demeter|Dillo|Dolfin|Dolphin http client|Dragon|Epiphany|EspialTVBrowser|Electron|Espial|Fennec|FireWeb|Fluid|Fresco|Galeon|Googlebot|Google Earth(?: EC)?|HbbTV|HotJava|IBrowse|iCab|Iceape|ICE Browser|IceCat|Iceweasel|IceWeasel|iRider|OneBrowser|Iris|Iron|Jasmine|Kapiko|Kazehakase|Kindle|K-Meleon|Lobo|Lunascape|Lynx|MacAppStore|Maemo Browser|Maxthon|mDolphin|Mercury|MiniBrowserMobile|Midori|Minimo|Net[Ff]ront|NetFrontLifeBrowser|NetPositive|Netscape|NetSurf|OmniWeb|Opera|Opera Mini|Orca|Otter|PaleMoon|Planetweb|Polaris|Puffin|PyAMF|QupZilla|qutebrowser|Raven for Mac|RockMelt|SailfishBrowser|SeaMonkey|Shiira|SkipStone|Skyfire|Sleipnir|Snowshoe|Space Bison|Stainless|Sunrise|ThunderBrowse|UP\.Browser|Vienna|Vivaldi|WebPilot|WebPositive|Xiino)[/ ](\d+)(?:\.(\d+)(?:\.(\d+))?)?'

  # Browser without version
  - regex: '(QIHU 360[SE]E)'

  # Chrome needs to come after as it hides a lot of browsers from previous regex
  - regex: '(Chrome)[/ ](\d+)(?:\.(\d+)(?:\.(\d+))?)?'

  - regex: '(Galeon|UP\.Browser)(?:[ /](\d+)(?:\.(\d+)(?:\.(\d+))?)?)?'

  - regex: '(Openwave)(?:/(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?'
    family: 'UP.Browser'

  # Dolphin Browser
  # @ref: http://www.dolphin.com
  - regex: '\b(Dolphin)(?: |/|HDCN/|/INT\-)(\d+)\.(\d+)\.?(\d+)?'

  # @note: needs to come after "Dolfin" as part of Samsung Bada UAs
  - regex: '\b(NexPlayer)\b(?:[ /]?(\d+)(?:\.(\d+)(?:\.(\d)+)?)?)?'
    type: 'mediaplayer'

  # IE Xbox
  # @ref: http://msdn.microsoft.com/en-us/library/ie/jj883727%28v=vs.85%29.aspx
  - regex: '(MSIE) (\d+)\.(\d+).*Xbox[^\-]'
    family: 'IE Xbox'
  # IE Mobile
  - regex: '(IEMobile)[ /](\d+)\.(\d+)'
    family: 'IE Mobile'
  # desktop mode
  # http://www.anandtech.com/show/3982/windows-phone-7-review
  - regex: '(MSIE) (\d+)\.(\d+).*XBLWP7'
    family: 'IE Large Screen'

  #### END MAIN CASES ####

  #### SPECIAL CASES ####
  - regex: '(Obigo|OBIGO|Teleca)(?:InternetBrowser|\-?Browser)?(?:[^\d]*0*(\d+)(?:.(\d+))?)?'
    family: 'Obigo'

  - regex: '(MAXTHON|Maxthon) (\d+)\.(\d+)'
    family: 'Maxthon'
  - regex: '(Maxthon|MyIE2|Uzbl|Shiira)'
    v1: '0'

  - regex: '(PLAYSTATION 3|PlayStation Portable)'
    family: 'NetFront'

  - regex: '(XBMC)/(\d+)\.(\d+)[-\w\s]+(r\d+)'

  - regex: '(ABrowse) (\d+)(?:\.(\d+))?'

  - regex: '(BrowseX) \((\d+)\.(\d+)\.(\d+)'

  - regex: '(NCSA[ _]Mosaic)(?:/(\d+)[\.-](\d+)(?:[\.-]?([a-z]?\d+))?)?'
    family: 'NCSA Mosaic'

  # Polaris/d.d is above
  - regex: '(POLARIS|Embider)/(\d+)\.(\d+)'
    family: 'Polaris'

  - regex: '(AvantGo) (\d+).(\d+)'

  - regex: '(Avant)'
    v1: '1'

  # This is the Tesla Model S (see similar entry in device parsers)
  - regex: '(QtCarBrowser)'
    v1: '1'

  - regex: '^(iBrowser/Mini)(\d+)\.(\d+)'
    family: 'iBrowser Mini'
  - regex: '^(iBrowser|iRAPP)/(\d+)\.(\d+)'

  - regex: '\b(IBrowse)(?:[ /](\d+)\.(\d+))?'

  # nokia browsers
  # based on: http://www.developer.nokia.com/Community/Wiki/User-Agent_headers_for_Nokia_devices
  - regex: '(NokiaBrowser|BrowserNG)/(\d+)\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?'
    family: 'Nokia Browser'
  - regex: 'Symbian.*(Series60)/5\.0'
    family: 'Nokia Browser'
    v1: '7'
    v2: '0'
  - regex: '(S40OviBrowser)/(\d+)\.(\d+)(?:\.(\d+))?(?:\.(\d+))?'
    family: 'Ovi Browser'
  - regex: '(Series60)/(\d+)\.(\d+).*AppleWebKit'
    family: 'Nokia OSS Browser'
  - regex: '(Series60)/(\d+)\.(\d+)'
    family: 'Nokia Services (WAP) Browser'
  - regex: '^(Nokia)'
    family: 'Nokia Services (WAP) Browser'
  - regex: '(Series80|Series90)/(\d)\.(\d)'
    family: 'Nokia $1 Browser'

  # BlackBerry devices
  - regex: '(PlayBook).+RIM Tablet OS (\d+)\.(\d+)\.(\d+)'
    family: 'BlackBerry WebKit'
  - regex: '(Black[bB]erry|BB10).+Version/(\d+)\.(\d+)\.(\d+)'
    family: 'BlackBerry WebKit'
  - regex: '(Black[bB]erry)\s?(\d+)'
    family: 'BlackBerry'

  # Palm
  - regex: 'Palm.*\b(Pre|Blazer|WebPro)\b(?:[ /](\d+)(?:\.(\d+)(?:\.(\d+[a-z]*))?)?)?'
    family: 'Palm $1'

  # Links/ Elinks
  - regex: '\b(E?[Ll]inks)(?: \(|\/)(\d+)\.(\d+)\.?(\d+)?'

  - regex: '(QtWeb) Internet Browser/(\d+)\.(\d+)'

  # Phantomjs, should go before Safari
  - regex: '(PhantomJS|CocoonJS)/(\d+)(?:\.(\d+)(?:\.(\d+))?)?'
    type: 'headless'

  # AppleWebKit / WebKit Nightly
  - regex: '(AppleWebKit)/(\d+)\.?(\d+)?\+ .* Safari'
    family: 'AppleWebKit'

  # Browser major_version.minor_version (space instead of slash)
  - regex: '(Android) (\d+)\.(\d+)\.?(\d+)?'

  # iOS
  - regex: '(iPod|iPhone|iPad)'

    group:
      # @ref http://stackoverflow.com/questions/2143763/
      - regex: '(iPod|iPhone|iPad).+Version/(\d+)\.(\d+)(?:\.(\d+))?.* Safari'
        family: 'Mobile Safari'
      - regex: '(iPod|iPhone|iPad).+Version/(\d+)\.(\d+)(?:\.(\d+))?.*'
        family: 'Mobile Safari UI/WKWebView'
        type: 'app'
      - regex: '(iPod|iPhone|iPad);.*CPU.*OS (\d+)_(\d+)(?:_(\d+))?.*Mobile.* Safari'
        family: 'Mobile Safari'
      - regex: '(iPod|iPhone|iPad);.*CPU.*OS (\d+)_(\d+)(?:_(\d+))?.*Mobile'
        family: 'Mobile Safari UI/WKWebView'
        type: 'app'
      - regex: '(iPod|iPhone|iPad).* Safari'
        family: 'Mobile Safari'
      - regex: '(iPod|iPhone|iPad)'
        family: 'Mobile Safari UI/WKWebView'
        type: 'app'

  # Safari
  - regex: '(Version)/(\d+)\.(\d+)(?:\.(\d+))?.*Safari/'
    family: 'Safari'
  # Safari didn't provide "Version/d.d.d" prior to 3.0
  - regex: '(Safari)/\d+'

  - regex: '(OLPC)/Update(\d+)\.(\d+)'
  - regex: '(OLPC)/Update()\.(\d+)'
    v1: '0'

  - regex: '(SEMC\-Browser)/(\d+)\.(\d+)'

  - regex: '(Phantom)/V(\d+)\.(\d+)'
    family: 'Phantom Browser'

  - regex: 'Trident(.*)rv:(\d+)\.(\d+)'
    family: 'IE'

  # AFTER THE EDGE CASES ABOVE!
  # AFTER IE11
  # BEFORE all other IE
  - regex: 'rv: ?(\d+)\.(\d+)\).*(Firefox)/[A-F0-9]{4}'
    family: '$3'
    v1: '$1'
    v2: '$2'
    v3: ''
  - regex: '(Firefox)/(\d+)(?:\.(\d+)(?:\.?(pre|[ab]?\d+[a-z]*))?)?'

  # Internet Explorer
  - regex: '(?:MS)?(IE)[ /](\d+)\.(\d+)'

  - regex: '(python-requests|(?:lib)?curl)(?:/(\d+)\.(\d+)(?:\.(\d+))?)?'
    type: 'headless'

  - regex: '(?:^|^Mozilla/\d+\.\d+ (?:\([^\)]+\) )?)(Java)[ /]?(\d+)(?:\.(\d+)(?:\.(\d+))?)?'
    type: 'headless'


#### Engine ####
engine_parsers:

  # MSIE compatibility modes
  - regex: 'Trident'
    group:
      # MSIE 8 !== Trident/4
      - regex: 'MSIE ([^8])\.\d.* (Trident)[ /](4)\.(\d+)\.?(\d+)?'
        family: '$2'
        v1: '$3'
        v2: '$4'
        v4: '$5'
        type: 'mode::MSIE $1'
      # MSIE 9 !== Trident/5
      - regex: 'MSIE ([^9])\.\d.* (Trident)[ /](5)\.(\d+)\.?(\d+)?'
        family: '$2'
        v1: '$3'
        v2: '$4'
        v4: '$5'
        type: 'mode::MSIE $1'
      # MSIE 10 !== Trident/6
      - regex: 'MSIE ((?:(?!10)\d)+)\.\d.* (Trident)[ /](6)\.(\d+)\.?(\d+)?'
        family: '$2'
        v1: '$3'
        v2: '$4'
        v4: '$5'
        type: 'mode::MSIE $1'
      # MSIE 11 !== Trident/7
      - regex: 'MSIE ((?:(?!11)\d)+)\.\d.* (Trident)[ /](7)\.(\d+)\.?(\d+)?'
        family: '$2'
        v1: '$3'
        v2: '$4'
        v4: '$5'
        type: 'mode::MSIE $1'

  - regex: '(Trident|Presto)[ /](\d+)\.(\d+)\.?(\d+)?'

  # Windows 10 IE version uses "Edge" and "Chrome"
  - regex: '\b(Edge)/(\d+)\.(\d+)'
    family: 'Trident'
    v1: '7'
    v2: '0'

  - regex: '(Chrome)[/](\d+)\.(\d+)\.?(\d+)?\.?(\d+)?.*OPR/\d+'
    family: 'Chrome::Opera'

  - regex: '^Mozilla.*(?:Android\b.*SAMSUNG|SMART-TV).*SamsungBrowser[/].*(Chrome)[/](\d+)\.(\d+)\.?(\d+)?\.?(\d+)??'
    family: 'Chrome::Samsung'

  # https://developer.chrome.com/multidevice/user-agent
  - regex: '(?:; wv\) )?AppleWeb[Kk]it/.*Version/.*(Chrome)[/](\d+)\.(\d+)\.?(\d+)?\.?(\d+)?'
    family: 'Chrome::WebView'

  - regex: '(Chrome)[/](\d+)\.(\d+)\.?(\d+)?\.?(\d+)?'

  - regex: '(Silk)/(\d+)\.(\d+)'

  - regex: 'Web[Kk]it.*(NokiaBrowser|BrowserNG)/(\d+)\.?(\d+)?\.?(\d+)?'
    family: 'Webkit::Nokia'

  - regex: '^Mozilla.*Android\b.*SAMSUNG.*(AppleWeb[Kk]it)/?(\d+)\.?(\d+)?'
    family: 'Webkit::Samsung'

  - regex: 'Android\b.*(AppleWeb[Kk]it)/?(\d+)\.?(\d+)?'
    family: 'Webkit::Android'

  - regex: '(?:DirectFB)\b.*(AppleWeb[Kk]it)/?(\d+)\.?(\d+)?'
    family: 'Webkit::LG'
  - regex: '(AppleWeb[Kk]it)/?(\d+)\.?(\d+)?.*\bNetCast'
    family: 'Webkit::LG'

  - regex: 'Smart-?TV\b.*(AppleWeb[Kk]it)/?(\d+)\.?(\d+)?'
    family: 'Webkit::Samsung'

  - regex: '(rv:)(\d+)\.(\d+[ab]?)\.?([ab]?\d+[a-z]*)?\.?(\d+[a-z]*)?[;\)].* Gecko(?:[ /]|$)'
    family: 'Gecko'

  - regex: '(AppleWeb[Kk]it)(?:/(\d+)\.?(\d+)?\.?(\d+)?|[ ,]|$)'
    family: 'Webkit::Apple'

  - regex: '(Web[Kk]it)(?:/(\d+)\.?(\d+)?\.?(\d+)?|[ ,]|$)'
    family: 'Webkit'

  - regex: '(Net[Ff]ront)[ /]?(\d+)\.(\d+)'
    family: 'Netfront'

  - regex: '(Gecko)/20\d{6}'

#### OS ####
os_parsers:

  - regex: 'UCWEB|JUC'
    group:
      # UCWEB
      - regex: '^UCWEB.*; (Adr) (\d+)\.(\d+)(?:[.\-]([a-z0-9]+))?;'
        family: 'Android'
      - regex: '^UCWEB.*; (iPad OS|iPh OS) (\d+)_(\d+)(?:_(\d+))?;'
        family: 'iOS'
      - regex: '^UCWEB.*; (wds) (\d+)\.(\d+)(?:\.(\d+))?;'
        family: 'Windows Phone'
      # JUC
      - regex: '^(JUC).*; ?U; ?(?:Android)?(\d+)\.(\d+)(?:[\.\-]([a-z0-9]+))?'
        family: 'Android'

  ##########
  # Windows
  # http://en.wikipedia.org/wiki/Windows_NT#Releases
  # possibility of false positive when different marketing names share same NT kernel
  # e.g. windows server 2003 and windows xp
  # lots of ua strings have Windows NT 4.1 !?!?!?!? !?!? !? !????!?! !!! ??? !?!?! ?
  # (very) roughly ordered in terms of frequency of occurence of regex (win xp currently most frequent, etc)
  ##########
  - regex: 'Win|CYGWIN'
    group:
      # @note: Xbox also spoofs NT 6.1/Windows Phone (see http://msdn.microsoft.com/en-us/library/ie/jj883728(v=vs.85).aspx)
      # @note: Xbox spoofs "Xbox LIVE/2.5.1704 CFNetwork/672.0.8 Darwin/14.0.0" iPhone App
      - regex: '\b(Xbox)\b(?:(?!Darwin).)*$'
      # ie mobile desktop mode
      # spoofs nt 6.1. must come before windows 7
      - regex: '(XBLWP7)'
        family: 'Windows Phone'

      # @note: These need to come before Windows NT 6.1
      - regex: '(Windows Phone) (?:OS[ /])?(\d+)\.(\d+)'
      - regex: '(Windows ?Mobile)'
        family: 'Windows Mobile'

      - regex: '(Windows ?CE)'
        family: 'Windows CE'

      - regex: '(Windows NT 6\.4)'
        family: 'Windows 10'
      - regex: '(Windows NT 10\.0|Windows 10\.0)'
        family: 'Windows 10'

      - regex: '(Windows NT 6\.3; ARM;)'
        family: 'Windows RT 8.1'
      - regex: '(Windows NT 6\.3|CYGWIN_NT-6\.3|Windows 8.1)'
        family: 'Windows 8.1'

      - regex: '(Windows NT 6\.2; ARM;)'
        family: 'Windows RT'
      - regex: '(Windows NT 6\.2|CYGWIN_NT-6\.2|Windows 8)'
        family: 'Windows 8'

      - regex: '(Windows NT 6\.1|CYGWIN_NT-6\.1|Windows 7)'
        family: 'Windows 7'

      - regex: '(Windows NT 6\.0|CYGWIN_NT-6\.0|Windows Vista)'
        family: 'Windows Vista'

      - regex: '(Windows NT 5\.2|CYGWIN_NT-5\.2|Windows Server 2003)'
        family: 'Windows Server 2003'

      - regex: '(Windows NT 5\.1|CYGWIN_NT-5\.1|Windows XP)'
        family: 'Windows XP'

      - regex: '(Windows NT 5\.0|CYGWIN_NT-5\.0|Win ?2000|Windows 2000)'
        family: 'Windows 2000'

      - regex: '(Windows NT 4\.0|CYGWIN_NT-4\.0|Win ?NT|Windows NT)'
        family: 'Windows NT'

      - regex: '(Win 9x 4\.90|CYGWIN_ME-4\.90|Win ?ME|Windows ME)'
        family: 'Windows ME'

      - regex: '(Win ?98|CYGWIN_98-4\.10|Windows 98)'
        family: 'Windows 98'

      - regex: '(Win32|Win ?95|CYGWIN_95-4\.0|Windows[ _]95)'
        family: 'Windows 95'

      - regex: '(Win16|Win ?3.\1|Windows 3\.1)'
        family: 'Windows 3.1'

      - regex: '(Windows)(?:(?!CFNetwork).)*$'

  - regex: '(?:Ali)?(YunOS)'
    regex_flag: 'i'
    group:
      # YunOS spoofs Android
      - regex: '(Android) (\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?.*(?:Ali)?(YunOS)-'
        regex_flag: 'i'
        family: 'YunOS'
      - regex: '(?:Ali)?(YunOS)[ /\-](\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?'
        regex_flag: 'i'
        family: 'YunOS'

  ##########
  # Android
  # can actually detect rooted android os. do we care?
  ##########
  - regex: '(Android)[ \-/](\d+)\.(\d+)(?:[.\-]([a-z0-9]+))?'

  - regex: 'Android|Build|Linux'
    group:
      - regex: '\((Linux); U; (\d+)\.(\d+)(?:[\.-](\d+|update1))?;'
        family: 'Android'

      - regex: '(Android) Donut'
        v1: '1'
        v2: '6'
      - regex: '(Android) Eclair'
        v1: '2'
        v2: '1'
      - regex: '(Android) Froyo'
        v1: '2'
        v2: '2'
      - regex: '(Android) Gingerbread'
        v1: '2'
        v2: '3'
      - regex: '(Android) Honeycomb'
        v1: '3'

      # https://source.android.com/source/build-numbers.html
      - regex: 'Build/(LRX22G)'
        family: 'Android'
        v1: '5'
        v2: '0'
        v3: '2'
      - regex: 'Build/(LRX22C)'
        family: 'Android'
        v1: '5'
        v2: '0'
        v3: '1'
      - regex: 'Build/(LRX21)'
        family: 'Android'
        v1: '5'
        v2: '0'
        v3: '0'
      - regex: 'Build/(KTU84Q|KTU84P)'
        family: 'Android'
        v1: '4'
        v2: '4'
        v3: '4'
      - regex: 'Build/(KTU84)'
        family: 'Android'
        v1: '4'
        v2: '4'
        v3: '3'
      - regex: 'Build/(KVT49L|KOT49H)'
        family: 'Android'
        v1: '4'
        v2: '4'
        v3: '2'
      - regex: 'Build/(KOT49)'
        family: 'Android'
        v1: '4'
        v2: '4'
        v3: '1'
      - regex: 'Build/(KRT16)'
        family: 'Android'
        v1: '4'
        v2: '4'
      - regex: 'Build/(JLS36I)'
        family: 'Android'
        v1: '4'
        v2: '3'
        v3: '1'
      - regex: 'Build/(JLS36|JSS15|JSR78|JWR66)'
        family: 'Android'
        v1: '4'
        v2: '3'
      - regex: 'Build/(JDQ39)'
        family: 'Android'
        v1: '4'
        v2: '2'
        v3: '2'
      - regex: 'Build/(JOP40)'
        family: 'Android'
        v1: '4'
        v2: '2'
        v3: '1'
      - regex: 'Build/(JZO54)'
        family: 'Android'
        v1: '4'
        v2: '1'
        v3: '2'
      - regex: 'Build/(JRO03)'
        family: 'Android'
        v1: '4'
        v2: '1'
        v3: '1'
      - regex: 'Build/(IMM76)'
        family: 'Android'
        v1: '4'
        v2: '0'
        v3: '4'
      - regex: 'Build/(IML77|IML74)'
        family: 'Android'
        v1: '4'
        v2: '0'
        v3: '3'
      - regex: 'Build/(ICL53)'
        family: 'Android'
        v1: '4'
        v2: '0'
        v3: '2'
      - regex: 'Build/(ITL41)'
        family: 'Android'
        v1: '4'
        v2: '0'
        v3: '1'
      - regex: 'Build/(HTK55|HTK75)'
        family: 'Android'
        v1: '3'
        v2: '2'
        v3: '1'
      - regex: 'Build/(GWK74|GRWK74)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '7'
      - regex: 'Build/(GINGERBREAD|GRK39)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '6'
      - regex: 'Build/(GRJ90)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '5'
      - regex: 'Build/(GRJ22|GRJ06D)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '4'
      - regex: 'Build/(GRJ22|GRJ06D)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '3'
      - regex: 'Build/(GRI54|GRI40)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '2'
      - regex: 'Build/(GRH78C)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '1'
      - regex: 'Build/(GRH78)'
        family: 'Android'
        v1: '2'
        v2: '3'
        v3: '1'
      - regex: 'Build/(GRH55)'
        family: 'Android'
        v1: '2'
        v2: '3'
      - regex: 'Build/(FRK76C|FRK76)'
        family: 'Android'
        v1: '2'
        v2: '2'
        v3: '3'
      - regex: 'Build/(FRG83G)'
        family: 'Android'
        v1: '2'
        v2: '2'
        v3: '2'
      - regex: 'Build/(FRG83)'
        family: 'Android'
        v1: '2'
        v2: '2'
        v3: '1'
      - regex: 'Build/(FROYO|FRG22D|FRG01B|FRF91|FRF85B)'
        family: 'Android'
        v1: '2'
        v2: '2'
      - regex: 'Build/(ECLAIR|EPF|ESE|EPE|ERE|ERD|ESD)'
        family: 'Android'
        v1: '2'
        v2: '1'
      - regex: 'Build/(CUPCAKE)'
        family: 'Android'
        v1: '1'
        v2: '5'

  # Raspbian
  - regex: '(Raspbian)[ \-/](\d+)\.(\d+)(?:[.\-]([a-z0-9]+))?'

  ##########
  # Kindle Android
  ##########
  - regex: '(Silk-Accelerated=[a-z]{4,5})'
    family: 'Android'

  # AmigaOS
  - regex: '(AmigaO[Ss]|AmigaVoyager|Amiga-AWeb)(?: ?(\d+)(?:\.(\d+))?)?'
    family: 'AmigaOS'

  ##########
  # Tizen OS from Samsung
  ##########
  - regex: '\b(Tizen)(?:[ /](\d+)\.(\d+))?'

  ##########
  # Mac OS
  # @ref: http://en.wikipedia.org/wiki/Mac_OS_X#Versions
  # @ref: http://www.puredarwin.org/curious/versions
  # @ref: http://user-agents.me/cfnetwork-version-list
  ##########
  - regex: 'Mac|Darwin|CFNetwork'

    group:
      - regex: '((?:Mac ?|; )OS X)[\s/](?:Version\s)?(?:(\d+)[_.](\d+)(?:[_.](\d+))?|Mach-O)'
        family: 'Mac OS X'

      # El Capitan
      - regex: ' Darwin/15\.0\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '11'
      # Yosemite
      - regex: 'CFNetwork/720\.(\d).* Darwin/14\.\d+'
        family: 'Mac OS X'
        v1: '10'
        v2: '10'
        v3: '$1'
      - regex: ' Darwin/14\.0\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '10'
      - regex: ' Darwin/14\.1\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '10'
        v3: '2'
      - regex: ' Darwin/14\.(\d)\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '10'
        v3: '$1'
      # Mavericks
      - regex: ' (Dar)(win)/(13)\.0\.2.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '9'
        v3: '1'
      - regex: ' (Dar)(win)/(13)\.1\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '9'
        v3: '2'
      - regex: ' (Dar)(win)/(13)\.2\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '9'
        v3: '3'
      - regex: ' (Dar)(win)/(13)\.3\.0.*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '9'
        v3: '4'
      - regex: ' (Dar)(win)/(13).(\d+).*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '9'
      # Mountain Lion
      - regex: 'CFNetwork/596\.(\d).* Darwin/12'
        family: 'Mac OS X'
        v1: '10'
        v2: '8'
        v3: '$1'
      - regex: ' (Dar)(win)/(12).(\d+).*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '8'
      # Lion
      - regex: 'CFNetwork/520\.(\d).* Darwin/11'
        family: 'Mac OS X'
        v1: '10'
        v2: '7'
        v3: '$1'
      - regex: ' (Dar)(win)/(11).(\d+).*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '7'
      # Snow Leopard
      - regex: ' (Dar)(win)/(10).(\d+).*\((?:i386|x86_64)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '6'
      # Leopard
      - regex: ' (Dar)(win)/(9).(\d+).*\((?:i386|x86_64|Power Macintosh)\)'
        family: 'Mac OS X'
        v1: '10'
        v2: '5'
      # builds before tiger don't seem to specify version?

      # ios devices spoof (mac os x), so including intel/ppc prefixes
      - regex: '(?:PPC|Intel) (Mac OS X)'

      # IE on Mac doesn't specify version number
      - regex: 'Mac_PowerPC'
        family: 'Mac OS'

      - regex: 'Macintosh'
        family: 'Mac OS'

  ##########
  # iOS
  # http://en.wikipedia.org/wiki/IOS_version_history
  ##########
  - regex: 'CPU OS|iPhone|iPad|iPod|iOS|Apple\s?TV|CFNetwork|tvOS'
    group:
      # Apple TV
      - regex: '(Apple\s?TV).* CPU OS (\d+)[_\.](\d+)(?:[_\.](\d+))?'
        family: 'ATV OS X'
      - regex: '(Apple\s?TV)[\d,]*(?:/(\d+)\.(\d+)(?:\.(\d+))?)?'
        family: 'ATV OS X'

      # General iOS
      - regex: '(CPU OS|iPhone OS|CPU iPhone) +(\d+)[_\.](\d+)(?:[_\.](\d+))?'
        family: 'iOS'

      # remaining cases are mostly only opera uas, so catch opera as to not catch iphone spoofs
      - regex: '(iPhone|iPad|iPod); Opera'
        family: 'iOS'

      # few more stragglers
      - regex: '(iPhone|iPad|iPod).*Mac OS X.*Version/(\d+)\.(\d+)'
        family: 'iOS'

      ##########
      # CFNetwork/Darwin - The specific CFNetwork or Darwin version determines whether the os maps to Mac OS, or iOS, or just Darwin.
      # @ref: https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
      # @ref: http://user-agents.me/cfnetwork-version-list
      ##########
      - regex: 'CFNetwork/758\.(\d)'
        family: 'iOS'
        v1: '9'
        v2: '$1'
      - regex: 'CFNetwork/711\.(\d).* Darwin/(14)\.\d+'
        family: 'iOS'
        v1: '8'
        v2: '$1'
      - regex: '(CFNetwork)/709\.1'
        family: 'iOS'
        v1: '8'
        v2: '0.b5'
      - regex: '(CFNetwork)/6(7)2\.(0)\.(?:2|8)'
        family: 'iOS'
      - regex: '(CF)(Network)/6(7)(2)\.1\.15'
        family: 'iOS'
        v1: '7'
        v2: '1'
      - regex: '(CFNetwork)/6(7)2\.(1)\.(1)4'
        family: 'iOS'
      - regex: '(CFNetwork)/6(7)2\.(1)\.13'
        family: 'iOS'
      - regex: '(CFNetwork)/(6)09\.(1)\.4'
        family: 'iOS'
      - regex: '(CFNetwork)/(6)(0)9'
        family: 'iOS'
      - regex: '(CFNetwork)/(5)48\.(0)\.4'
        family: 'iOS'
        v3: '1'
      - regex: '(CFNetwork)/(5)48\.(\d)'
        family: 'iOS'
      - regex: '(CFNetwork)/(4)85\.1(3)\.9'
        family: 'iOS'

      - regex: 'CFNetwork/7.* Darwin/(15)\.\d+'
        family: 'iOS'
        vi: '9'
      - regex: 'CFNetwork/7.* Darwin/(14)\.\d+'
        family: 'iOS'
        v1: '8'
      - regex: 'CFNetwork/6.* Darwin/(14)\.\d+'
        family: 'iOS'
        v1: '7'
      - regex: 'CFNetwork/.* Darwin/(13)\.\d+'
        family: 'iOS'
        v1: '6'
      - regex: 'CFNetwork/.* Darwin/(11)\.\d+'
        family: 'iOS'
        v1: '5'
      - regex: 'CFNetwork/.* Darwin/(10)\.\d+'
        family: 'iOS'
        v1: '4'
      - regex: 'CFNetwork/.* Darwin/(9)\.\d+'
        family: 'iOS'
        v1: '1'

      # iOS Apps
      - regex: '\b(iOS[ /]|iPhone(?:/| v|[ _]OS[/,]|; | OS : |\d,\d/|\d,\d; )|iPad/)(\d{1,2})[_\.](\d{1,2})(?:[_\.](\d+))?'
        family: 'iOS'

      ##########
      # Apple TV
      ##########
      - regex: '(tvOS)/(\d+).(\d+)'
        family: 'tvOS'


  ##########
  # Chrome OS
  # if version 0.0.0, probably this stuff:
  # http://code.google.com/p/chromium-os/issues/detail?id=11573
  # http://code.google.com/p/chromium-os/issues/detail?id=13790
  ##########
  - regex: '(CrOS) [a-z0-9_]+ (\d+)\.(\d+)(?:\.(\d+))?'
    family: 'Chrome OS'

  ##########
  # Symbian + Symbian OS
  # http://en.wikipedia.org/wiki/History_of_Symbian
  ##########
  - regex: 'Symbian|Series|MeeGo|S60'
    group:
      - regex: '(Symbian[Oo][Ss])[/ ](\d+)\.(\d+)'
        family: 'Symbian OS'
      - regex: '(Symbian/3).+NokiaBrowser/7\.3'
        family: 'Symbian^3 Anna'
      - regex: '(Symbian/3).+NokiaBrowser/7\.4'
        family: 'Symbian^3 Belle'
      - regex: '(Symbian/3)'
        family: 'Symbian^3'
      - regex: '\b(Series 60|SymbOS|S60Version|S60V\d|S60\b)'
        family: 'Symbian OS'
      - regex: '(MeeGo)'
      - regex: 'Symbian [Oo][Ss]'
        family: 'Symbian OS'
      - regex: 'Series40;'
        family: 'Nokia Series 40'
      - regex: 'Series30Plus;'
        family: 'Nokia Series 30 Plus'

  ##########
  # BlackBerry devices
  ##########
  - regex: 'BB10|BlackBerry|Rim'
    regex_flag: 'i'
    group:
      - regex: '(BB10);.+Version/(\d+)\.(\d+)\.(\d+)'
        family: 'BlackBerry OS'
      - regex: '(Black[Bb]erry)[0-9a-z]+/(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?'
        family: 'BlackBerry OS'
      - regex: '(Black[Bb]erry).+Version/(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?'
        family: 'BlackBerry OS'
      - regex: '(RIM Tablet OS) (\d+)\.(\d+)\.(\d+)'
        family: 'BlackBerry Tablet OS'
      - regex: '(Play[Bb]ook)'
        family: 'BlackBerry Tablet OS'
      - regex: '(Black[Bb]erry)'
        family: 'BlackBerry OS'

  ##########
  # Firefox OS
  # https://developer.mozilla.org/en-US/docs/Web/HTTP/Gecko_user_agent_string_reference
  ##########

  - regex: '\((Mobile|Tablet);.+Firefox'
    group:
      - regex: '\((?:Mobile|Tablet);.+Gecko/18.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '1'
        v2: '0'
        v3: '1'
      - regex: '\((?:Mobile|Tablet);.+Gecko/18.1 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '1'
        v2: '1'
      - regex: '\((?:Mobile|Tablet);.+Gecko/26.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '1'
        v2: '2'
      - regex: '\((?:Mobile|Tablet);.+Gecko/28.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '1'
        v2: '3'
      - regex: '\((?:Mobile|Tablet);.+Gecko/30.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '1'
        v2: '4'
      - regex: '\((?:Mobile|Tablet);.+Gecko/32.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '2'
        v2: '0'
      - regex: '\((?:Mobile|Tablet);.+Gecko/34.0 Firefox/\d+\.\d+'
        family: 'Firefox OS'
        v1: '2'
        v2: '1'
      # general matcher
      - regex: '\((Mobile|Tablet);.+Firefox/\d+\.\d+'
        family: 'Firefox OS'

  ##########
  # BREW
  # yes, Brew is lower-cased for Brew MP
  ##########
  - regex: 'BREW|BMP|Brew'
    group:
      - regex: '(BREW)[ /](\d+)\.(\d+)\.(\d+)'
      - regex: '(BREW);'
      - regex: '(Brew MP|BMP)[ /](\d+)\.(\d+)\.(\d+)'
        family: 'Brew MP'
      - regex: 'BMP;'
        family: 'Brew MP'

  ##########
  # Google TV
  ##########
  - regex: '(GoogleTV)(?: (\d+)\.(\d+)(?:\.(\d+))?|/[\da-z]+)'

  - regex: '(WebTV)/(\d+).(\d+)'

  ##########
  # Misc mobile
  ##########
  - regex: '(hpw|web)OS[ /](\d+)\.(\d+)(?:\.(\d+))?'
    family: 'webOS'
  - regex: '(Palm ?OS)'
    family: 'PalmOS'
  - regex: 'Xiino(?:.*v\. (\d+[\.\d]+))?'
    family: 'PalmOS'
  - regex: '(VRE);'

  ##########
  # HbbTV vendors
  ##########
  - regex: 'HbbTV'
    group:
      - regex: 'HbbTV/\d+\.\d+\.\d+ \( ;(LG)E ;NetCast 4.0'
        v1: '2013'
      - regex: 'HbbTV/\d+\.\d+\.\d+ \( ;(LG)E ;NetCast 3.0'
        v1: '2012'
      - regex: 'HbbTV/1.1.1 \(;;;;;\) Maple_2011'
        family: 'Samsung'
        v1: '2011'
      - regex: 'HbbTV/\d+\.\d+\.\d+ \(;(Samsung);SmartTV([0-9]{4});.*FXPDEUC'
        v2: 'UE40F7000'
      - regex: 'HbbTV/\d+\.\d+\.\d+ \(;(Samsung);SmartTV([0-9]{4});.*MST12DEUC'
        v2: 'UE32F4500'
      - regex: 'HbbTV/1.1.1 \(; (Philips);.*NETTV/4'
        v1: '2013'
      - regex: 'HbbTV/1.1.1 \(; (Philips);.*NETTV/3'
        v1: '2012'
      - regex: 'HbbTV/1.1.1 \(; (Philips);.*NETTV/2'
        v1: '2011'
      # the HbbTV emulator developers use HbbTV/1.1.1 (;;;;;) firetv-firefox-plugin 1.1.20
      - regex: 'HbbTV/\d+\.\d+\.\d+.*(firetv)-firefox-plugin (\d+).(\d+).(\d+)'
        family: 'FireHbbTV'
      # generic HbbTV, hoping to catch manufacturer name (always after 2nd comma) and the first string that looks like a 2011-2019 year
      - regex: 'HbbTV/\d+\.\d+\.\d+ \(.*; ?([a-zA-Z]+) ?;.*(201[1-9]).*\)'

  # Other OS
  - regex: '\b(Sailfish|Haiku|BeOS)\b'

  # RISC OS
  - regex: '(RISC OS)(?:-NC)?(?:[ /](?:\.(\d+)(?:\.(\d+))?)?)?'

  # Gaming Console
  - regex: '(Nintendo Wii)'
  - regex: '(Xbox|KIN\.(?:One|Two))'
    name: 'Xbox'
    v1: '360'

  - regex: 'PlayStation (\d+)'
    regex_flag: 'i'
    family: 'Playstation $1'
  # Mobile Gaming Console
  - regex: '(Nitro|Nintendo) ([3]?DS[i]?)'
    family: 'Nintendo Mobile'
  - regex: 'PlayStation (Portable|Vita)'
    family: 'PlayStation $1'

  ##########
  # Linux distros and others
  ##########
  - regex: '(Fedora|Ubuntu|Red Hat|(?:Free|Open|Net|\b)BSD|[KLX]?ubuntu|Arch ?Linux|Bada|CentOS|Debian|Fedora|Gentoo|HopenOS|Kindle|Knoppix|Mageia|Mandriva|Mint|openSUSE|PCLinuxOS|Puppy|Sabayon|Slackware|SUSE|BackTrack|SunOS|Solaris|AIX|HP-UX|DragonFly|Syllable|IRIX)\b(?:(?: Enterprise)? Linux)?(?:[ /\-](\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?)?'

  - regex: 'OSF1(?:[/ ]?v?(\d+)(?:\.(\d)+)?)?'
    family: 'OSF1'

  # just os
  - regex: '(Windows|Android|WeTab|Maemo|\bOS/2\b|WinGogi|GOGI)'

  # Gentoo Linux + Kernel Version
  - regex: '(Linux)[ /](\d+)\.(\d+)(?:\.(\d+))?.*gentoo'
    family: 'Gentoo'

  # Linux + Kernel Version
  - regex: '(Linux)(?:[ /](\d+)\.(\d+)(?:\.(\d+))?)?'

  - regex: 'X11;'
    family: 'Linux'

#### Device ####
device_parsers:

  ######################################################################
  # Android parsers
  #
  # @ref: https://support.google.com/googleplay/answer/1727131?hl=en
  ######################################################################
  - regex: '[Aa]ndroid| Build| Adr |JUC|\bHTC|Linux|Archos'
    group:

      #########
      # WebBrowser for SmartWatch
      # @ref: https://play.google.com/store/apps/details?id=se.vaggan.webbrowser&hl=en
      #########
      - regex: '\bSmartWatch *\( *([^;]+) *; *([^;]+) *;'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      # Android Application
      - regex: 'Android Application'
        group:
          - regex: 'Android Application[^\-]+ - (Sony) ?(Ericsson)? (.+) \w+ - '
            device: '$1 $2'
            brand: '$1$2'
            model: '$3'
          - regex: 'Android Application[^\-]+ - (?:HTC|HUAWEI|LGE|LENOVO|MEDION|TCT) (HTC|HUAWEI|LG|LENOVO|MEDION|ALCATEL)[ _\-](.+) \w+ - '
            regex_flag: 'i'
            device: '$1 $2'
            brand: '$1'
            model: '$2'
          - regex: 'Android Application[^\-]+ - ([^ ]+) (.+) \w+ - '
            device: '$1 $2'
            brand: '$1'
            model: '$2'

      #########
      # Huawei
      # @ref: http://www.huaweidevice.com
      # @note: Needs to be before HTC due to Desire HD Build on U8815
      #########
      - regex: 'huawei|[uc]\d{4}|ideos|ascend|honor|m8\d{2}|s7|H60-L'
        regex_flag: 'i'
        group:
          - regex: '; *(HUAWEI |Huawei-)?([UY][^;/]+) Build/(?:Huawei|HUAWEI)([UY][^\);]+)\)'
            device: '$1$2'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *([^;/]+) Build[/ ]Huawei(MT1-U06|[A-Z]+\d+[^\);]+)[^\);]*\)'
            device: '$1'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *(S7|M860|H60-L\d+) Build'
            device: '$1'
            brand: 'Huawei'
            model: '$1'
          - regex: '; *((?:HUAWEI|Huawei)[ \-]?)(MediaPad) Build'
            device: '$1$2'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *((?:HUAWEI[ _]?|Huawei[ _])?Ascend[ _])([^;/]+) Build'
            device: '$1$2'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *((?:HUAWEI|Huawei)[ _\-]?)((?:G700-|MT-)[^;/]+) Build'
            device: '$1$2'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *((?:HUAWEI|Huawei)[ _\-]?)([^;/]+) Build'
            device: '$1$2'
            brand: 'Huawei'
            model: '$2'
          - regex: '; *(MediaPad[^;]+|SpringBoard) Build/Huawei'
            device: '$1'
            brand: 'Huawei'
            model: '$1'
          - regex: '; *([^;]+) Build/Huawei'
            device: '$1'
            brand: 'Huawei'
            model: '$1'
          - regex: '; *([Uu])([89]\d{3}) Build'
            device: '$1$2'
            brand: 'Huawei'
            model: 'U$2'
          - regex: '; *(Ideos|IDEOS|HONOR) ([^;/]+\s*|\s*)Build'
            device: 'Huawei $1 $2'
            brand: 'Huawei'
            model: '$1 $2'

      - regex: '; *(?:[^;]+) Build/(Orange[^\s\)]+)'
        device: 'Huawei $1'
        brand: 'Huawei'
        model: '$1'
      - regex: '; *(Orange Daytona|Pulse|Pulse Mini|Vodafone 858|C8500|C8600|C8650|C8660|Nexus 6P) Build'
        device: 'Huawei $1'
        brand: 'Huawei'
        model: '$1'

      #########
      # Samsung Android Devices
      # @ref: http://www.samsung.com/us/mobile/cell-phones/all-products
      #########
      - regex: 'samsung|behold|ek-|galaxy|gt-|nexus|sch-|scl|sgh-|shv-|shw-|sm-|sph-|yp-'
        regex_flag: 'i'
        group:
          - regex: '; *(SAMSUNG |Samsung )?((?:Galaxy (?:Note II|S\d)|GT-I9082|GT-I9205|GT-N7\d{3}|SM-N9005)[^;/]*)\/?[^;/]* Build/'
            device: '$1$2'
            brand: 'Samsung'
            model: '$2'
          - regex: '; *(Google )?(Nexus [Ss](?: 4G)?) Build/'
            device: '$1$2'
            brand: 'Samsung'
            model: '$2'
          - regex: '; *(SAMSUNG |Samsung )([^\/]*)\/[^ ]* Build/'
            device: '$1$2'
            brand: 'Samsung'
            model: '$2'
          - regex: '; *(Galaxy(?: Ace| Nexus| ACE| S ?II+|Nexus S| with MCR 1.2| Mini Plus 4G)?) Build/'
            device: '$1'
            brand: 'Samsung'
            model: '$1'
          - regex: '; *(SAMSUNG[ _\-] *)+([^;/]+) Build'
            device: '$1$2'
            brand: 'Samsung'
            model: '$2'
          - regex: '; *(SAMSUNG-)?(GT\-[BINPS]\d{4}[^\/]*)(\/[^ ]*) Build'
            device: '$1$2$3'
            brand: 'Samsung'
            model: '$2'
          - regex: '(?:; *|^)((?:GT\-[BIiNPS]\d{4}|I9\d{2}0[A-Za-z\+]?\b)[^;/\)]*?)(?:Build|Linux|MIUI|[;/\)])'
            device: '$1'
            brand: 'Samsung'
            model: '$1'
          - regex: '; (SAMSUNG-)([A-Za-z0-9\-]+).* Build/'
            device: '$1$2'
            brand: 'Samsung'
            model: '$2'
          - regex: '; *((?:SCH|SGH|SHV|SHW|SPH|SC|SM)\-[A-Za-z0-9 ]+)(/?[^ ]*)? Build'
            device: '$1'
            brand: 'Samsung'
            model: '$1'
          - regex: ' ((?:SCH)\-[A-Za-z0-9 ]+)(/?[^ ]*)? Build'
            device: '$1'
            brand: 'Samsung'
            model: '$1'
          - regex: '; *(Behold ?(?:2|II)|YP\-G[^;/]+|SCL21|I9300) Build'
            device: 'Samsung $1'
            brand: 'Samsung'
            model: '$1'
          - regex: '; *(EK-GC\d{3}) Build'
            device: 'Samsung $1'
            brand: 'Samsung'
            model: '$1'
            type: 'camera'

      #########
      # 3Q
      # @ref: http://www.3q-int.com/
      # @models: xl65 , s-4
      #########
      - regex: '; *(AC07\d{2}[A-Z]|BC9710AM|EL72B|ER71B|LC(?:07|08|09|10)\d{2}[A-Z]?|MT(?:07|08|09|10|78)\d{2}[A-Z]?|OC1020A|QS(?:07|08|10|97)\d{2}[A-Z]|RC(?:07|08|10|13|78|97)\d{2}[A-Z]|TS(?:08|10)\d{2}[A-Z]|VM(?:07|10)\d{2}[A-Z]) +Build/'
        device: '3Q $1'
        brand: '3Q'
        model: '$1'
      - regex: '; *(?:3Q_)([^;/]+) +Build'
        device: '3Q $1'
        brand: '3Q'
        model: '$1'

      #########
      # Acer
      # @ref: http://us.acer.com/ac/en/US/content/group/tablets
      #########
      - regex: 'acer|[abesvwz]\d{2,3}|a1-|b1-|liquid|slider'
        regex_flag: 'i'
        group:
          - regex: 'Android [34].*; *(A100|A101|A110|A200|A210|A211|A500|A501|A510|A511|A700(?: Lite| 3G)?|A701|B1-A71|A1-\d{3}(?:F?HD)?|A3-A\d{2}(?:F?HD)?|[bB]1-\d{3}(?:F?HD)?) Build'
            device: '$1'
            brand: 'Acer'
            model: '$1'
            type: 'tablet'
          - regex: '; *([A-Z]\d{3}) Build.*Acer'
            device: '$1'
            brand: 'Acer'
            model: '$1'
          - regex: 'Android [34].*; *(V360|V370|W500|W500P|W501|W501P|W510|W511|W700|Slider SL101|DA22[^;/]+) Build'
            device: '$1'
            brand: 'Acer'
            model: '$1'
          - regex: '(Acer)(?:[ _-]|\/acer; )?([^;\)]+)(?: Build|;)'
            device: '$1 $2'
            brand: 'Acer'
            model: '$2'
          - regex: '; *Acer (Iconia Tab) ([^;/]+) Build'
            device: '$2'
            brand: 'Acer'
            model: '$2'
            type: 'tablet'
          - regex: '; *(Z1[123456]0|Z200|Z410|Z500|E3[28]0[^/]*|E39|S5[012]0|S5[56]|Liquid[^;/]*|Iconia A\d+) Build'
            device: '$1'
            brand: 'Acer'
            model: '$1'
          - regex: '; *(Acer |ACER )([^;/]+) Build'
            device: '$1$2'
            brand: 'Acer'
            model: '$2'

      #########
      # Advan
      # @ref: http://www.advandigital.com/
      #########
      - regex: '(ADVAN)[ _]([^\s\)_]+)'
        device: '$1$2'
        brand: 'Advan'
        model: '$2'

      #########
      # Advent
      # @ref: https://en.wikipedia.org/wiki/Advent_Vega
      # @note: VegaBean and VegaComb (names derived from jellybean, honeycomb) are
      #   custom ROM builds for Vega
      #########
      - regex: '; *(Advent )?(Vega(?:Bean|Comb)?).* Build'
        device: '$1$2'
        brand: 'Advent'
        model: '$2'

      #########
      # Ainol
      # @ref: http://www.ainol.com/plugin.php?identifier=ainol&module=product
      #########
      - regex: '; *(Ainol )?((?:NOVO|[Nn]ovo)[^;/]+) Build'
        device: '$1$2'
        brand: 'Ainol'
        model: '$2'

      #########
      # Airis
      # @ref: http://airis.es/Tienda/Default.aspx?idG=001
      #########
      - regex: '; *AIRIS[ _\-]?([^/;\)]+) *(?:;|\)|Build)'
        regex_flag: 'i'
        device: '$1'
        brand: 'Airis'
        model: '$1'
      - regex: '; *(OnePAD[^;/]+) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Airis'
        model: '$1'

      #########
      # Airpad
      # @ref: ??
      #########
      - regex: '; *Airpad[ \-]([^;/]+) Build'
        device: 'Airpad $1'
        brand: 'Airpad'
        model: '$1'

      #########
      # Alcatel - TCT
      # @ref: http://www.alcatelonetouch.com/global-en/products/smartphones.html
      #########
      - regex: '; *(one ?touch) (EVO7|T10|T20) Build'
        device: 'Alcatel One Touch $2'
        brand: 'Alcatel'
        model: 'One Touch $2'
      - regex: '; *(?:USCC[_\-]ALCATEL[_\-]|alcatel[ _])?(?:(?:one[ _\-]?touch[ _\-])|ot[ _\-])([^;/]+);?(?: Build|\))'
        regex_flag: 'i'
        device: 'Alcatel One Touch $1'
        brand: 'Alcatel'
        model: 'One Touch $1'
      - regex: '; *([456]\d{3}[A-Z]) Build'
        regex_flag: 'i'
        device: 'Alcatel One Touch $1'
        brand: 'Alcatel'
        model: 'One Touch $1'
      - regex: '; *(TCL|Alcatel)[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      # operator specific models
      - regex: '; *(Vodafone[ _]Smart[ _]II|Optimus_Madrid|Orange (?:Infinity 8008X|Hiro|Yomi)|Telenor[_ ](?:Smart|One_?Touch)([_ ][^;]*?)?|move 2|BS471|I213|Mobile Sosh|MTC975|smart_a17|7040[NRT]) Build'
        device: 'Alcatel $1'
        brand: 'Alcatel'
        model: '$1'
      - regex: '; *BASE_Lutea_3 Build'
        device: 'Alcatel One Touch 998'
        brand: 'Alcatel'
        model: 'One Touch 998'
      - regex: '; *BASE_Varia Build'
        device: 'Alcatel One Touch 918D'
        brand: 'Alcatel'
        model: 'One Touch 918D'

      #########
      # Allfine
      # @ref: http://www.myallfine.com/Products.asp
      #########
      - regex: '; *((?:FINE|Fine)\d[^;/]+) Build'
        device: '$1'
        brand: 'Allfine'
        model: '$1'

      #########
      # Allview
      # @ref: http://www.allview.ro/produse/droseries/lista-tablete-pc/
      #########
      - regex: '; *(ALLVIEW[ _]?|Allview[ _]?)((?:Speed|SPEED).*) Build/'
        device: '$1$2'
        brand: 'Allview'
        model: '$2'
      - regex: '; *(ALLVIEW[ _]?|Allview[ _]?)?(A4DUO|A5_Quad|AX1_Shine|AX2_Frenzy|AX4Nano|X\d_Soul|X\d_mini_Soul|X2_Twin|V\d_Viper[^;/]|E2_Living|A5Smiley|P5|P5_Quad|P6_Quad|P6Life) Build'
        device: '$1$2'
        brand: 'Allview'
        model: '$2'
      - regex: '; *(ALLVIEW[ _]?|Allview[ _]?)([^;/]*) Build'
        device: '$1$2'
        brand: 'Allview'
        model: '$2'

      #########
      # Allwinner
      # @ref: http://www.allwinner.com/
      # @models: A31 (13.3"),A20,A10,
      #########
      - regex: '; *(A13-MID|Q8H) Build'
        device: '$1'
        brand: 'Allwinner'
        model: '$1'
      - regex: '; *(Allwinner)[ _\-]?([^;/]+) Build'
        device: '$1 $2'
        brand: 'Allwinner'
        model: '$1'

      #########
      # Amaway
      # @ref: http://www.amaway.cn/
      #########
      - regex: '; *(A651|A701B?|A702|A703|A705|A706|A707|A711|A712|A713|A717|A722|A785|A801|A802|A803|A901|A902|A1002|A1003|A1006|A1007|A9701|A9703|Q710|Q80) Build'
        device: '$1'
        brand: 'Amaway'
        model: '$1'

      #########
      # Amoi
      # @ref: http://www.amoi.com/en/prd/prd_index.jspx
      #########
      - regex: '; *(?:AMOI|Amoi)[ _]([^;/]+) Build'
        device: 'Amoi $1'
        brand: 'Amoi'
        model: '$1'
      - regex: '^(?:AMOI|Amoi)[ _]([^;/]+) Linux'
        device: 'Amoi $1'
        brand: 'Amoi'
        model: '$1'
      - regex: '; *(A\d{3}W) Build'
        device: 'Amoi $1'
        brand: 'Amoi'
        model: '$1'

      #########
      # Aoc
      # @ref: http://latin.aoc.com/media_tablet
      #########
      - regex: '; *(?:(MW(?:0[789]|10)[^;/]+)|AOC (U702)) Build'
        device: '$1$2'
        brand: 'Aoc'
        model: '$1$2'

      #########
      # Aoson
      # @ref: http://www.luckystar.com.cn/en/mid.aspx?page=1
      # @ref: http://www.luckystar.com.cn/en/mobiletel.aspx?page=1
      # @note: brand owned by luckystar
      #########
      - regex: '; *(G7|M1013|M1015G|M11[CG]?|M-?12[B]?|M15|M19[G]?|M30[ACQ]?|M31[GQ]|M32|M33[GQ]|M36|M37|M38|M701T|M710|M712B|M713|M715G|M716G|M71(?:G|GS|T)?|M72[T]?|M73[T]?|M75[GT]?|M77G|M79T|M7L|M7LN|M81|M810|M81T|M82|M92|M92KS|M92S|M717G|M721|M722G|M723|M725G|M739|M785|M791|M92SK|M93D) Build'
        device: 'Aoson $1'
        brand: 'Aoson'
        model: '$1'
      - regex: '; *Aoson ([^;/]+) Build'
        regex_flag: 'i'
        device: 'Aoson $1'
        brand: 'Aoson'
        model: '$1'

      #########
      # Apanda
      # @ref: http://www.apanda.com.cn/
      #########
      - regex: '; *[Aa]panda[ _\-]([^;/]+) Build'
        device: 'Apanda $1'
        brand: 'Apanda'
        model: '$1'

      #########
      # Archos
      # @ref: http://www.archos.com/de/products/tablets.html
      # @ref: http://www.archos.com/de/products/smartphones/index.html
      #########
      - regex: '; *(?:ARCHOS|Archos) ?(GAMEPAD.*?)(?: Build|[;/\(\)\-])'
        device: 'Archos $1'
        brand: 'Archos'
        model: '$1'
        type: 'console'
      - regex: 'ARCHOS; GOGI; ([^;]+);'
        device: 'Archos $1'
        brand: 'Archos'
        model: '$1'
      - regex: '(?:ARCHOS|Archos)[ _;]?(.*?)(?: Build|[;/\(\)\-]|$)'
        device: 'Archos $1'
        brand: 'Archos'
        model: '$1'
      - regex: '; *(A28|A32|A43|A70(?:BHT|CHT|HB|S|X)|A101(?:B|C|IT)|A7EB|A7EB-WK|101G9|80G9) Build'
        device: 'Archos $1'
        brand: 'Archos'
        model: '$1'

      #########
      # A-rival
      # @ref: http://www.a-rival.de/de/
      #########
      - regex: '; *(PAD-FMD[^;/]+) Build'
        device: '$1'
        brand: 'Arival'
        model: '$1'
      - regex: '; *(BioniQ) ?([^;/]+) Build'
        device: '$1 $2'
        brand: 'Arival'
        model: '$1 $2'

      #########
      # Arnova
      # @ref: http://arnovatech.com/
      #########
      - regex: '; *(AN(?:7|8|9|10|13)[A-Z0-9]{1,4}) Build'
        device: 'Arnova $1'
        brand: 'Arnova'
        model: '$1'
      - regex: '; *(AN\d[^;/]+|ARCHM\d+) Build'
        device: 'Arnova $1'
        brand: 'Arnova'
        model: '$1'
      - regex: '; *(?:ARNOVA|Arnova) ?([^;/]+) Build'
        device: 'Arnova $1'
        brand: 'Arnova'
        model: '$1'

      #########
      # Assistant
      # @ref: http://www.assistant.ua
      #########
      - regex: '; *(?:ASSISTANT )?(AP)-?([1789]\d{2}[A-Z]{0,2}|80104) Build'
        device: 'Assistant $1-$2'
        brand: 'Assistant'
        model: '$1-$2'

      #########
      # Asus
      # @ref: http://www.asus.com/uk/Tablets_Mobile/
      #########
      - regex: '; *(A500CG|AST21|ME(?:[13]\d{2})[^;/]+|K0[01][A-Z0-9]|Nexus 10|Nexus 7(?: 2013| LTE)?|Nexus HDX 7|PadFone[^;/]*|Transformer[^;/]*|TF\d{3}[^;/]*|TX201LA|eeepc) Build'
        device: 'Asus $1'
        brand: 'Asus'
        model: '$1'
      - regex: '; *ASUS[ _]*([^;/]+) Build'
        device: 'Asus $1'
        brand: 'Asus'
        model: '$1'

      #########
      # Avvio
      # @ref: http://www.avviomobile.com
      #########
      - regex: '(Avvio)[ _\-]?(pad[a-z0-9\-\.]*)'
        regex_flag: 'i'
        brand: 'Avvio'
        model: '$2'
        type: 'tablet'
      - regex: '(Avvio)[ _\-]?([a-z0-9\-\.]+)'
        regex_flag: 'i'
        brand: 'Avvio'
        model: '$2'
        type: 'smartphone'

      #########
      # Garmin-Asus
      #########
      - regex: '; *Garmin-Asus ([^;/]+) Build'
        device: 'Garmin-Asus $1'
        brand: 'Garmin-Asus'
        model: '$1'
      - regex: '; *(Garminfone) Build'
        device: 'Garmin $1'
        brand: 'Garmin-Asus'
        model: '$1'

      #########
      # Attab
      # @ref: http://www.theattab.com/
      #########
      - regex: '; (@TAB-[^;/]+) Build'
        device: '$1'
        brand: 'Attab'
        model: '$1'

      #########
      # Audiosonic
      # @ref: ??
      # @note: Take care with Docomo T-01 Toshiba
      #########
      - regex: '; *(T-(?:07|[^0]\d)[^;/]+) Build'
        device: '$1'
        brand: 'Audiosonic'
        model: '$1'

      #########
      # Avus
      # @ref: http://www.avus.cc/
      #########
      - regex: '; AVUS ([^;/]+) Build'
        device: '$1'
        brand: 'Avus'
        model: '$1'

      #########
      # Axioo
      # @ref: http://www.axiooworld.com/ww/index.php
      #########
      - regex: ' (?:Axioo[ _\-]([^;/]+)|(pico(?:pad|phone))[ _\-]([^;/]+)) ?(?:Build|;|\))'
        regex_flag: 'i'
        device: 'Axioo $1$2 $3'
        brand: 'Axioo'
        model: '$1$2 $3'

      #########
      # Azend
      # @ref: http://azendcorp.com/index.php/products/portable-electronics
      #########
      - regex: '; *(V(?:100|700|800)[^;/]*) Build'
        device: '$1'
        brand: 'Azend'
        model: '$1'

      #########
      # Azumi
      # @ref: http://azumi-mobile.com/
      #########
      - regex: '; *(Azumi)[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Azumi'
        model: '$2'
      - regex: '; *(A35S) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Azumi'
        model: '$1'

      #########
      # Bak
      # @ref: http://www.bakinternational.com/produtos.php?cat=80
      #########
      - regex: '; *(IBAK\-[^;/]*) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Bak'
        model: '$1'

      #########
      # Bangho
      # @ref: http://www.bangho.com.ar
      #########
      - regex: '; (AERO J\d+|Aero1021)[\s/].*Build'
        brand: 'Bangho'
        model: '$1'

      #########
      # Bedove
      # @ref: http://www.bedove.com/product.html
      # @models: HY6501|HY5001|X12|X21|I5
      #########
      - regex: '; *(HY5001|HY6501|X12|X21|I5) Build'
        device: 'Bedove $1'
        brand: 'Bedove'
        model: '$1'

      #########
      # Benss
      # @ref: http://www.benss.net/
      #########
      - regex: '; *(JC-[^;/]*) Build'
        device: 'Benss $1'
        brand: 'Benss'
        model: '$1'

      #########
      # Blackberry
      # @ref: http://uk.blackberry.com/
      # @note: Android Apps seams to be used here
      #########
      - regex: '; *(BB) ([^;/]+) Build'
        device: '$1 $2'
        brand: 'Blackberry'
        model: '$2'

      #########
      # Blackbird
      # @ref: http://iblackbird.co.kr
      #########
      - regex: '; *(BlackBird)[ _](I8.*) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      - regex: '; *(BlackBird)[ _](.*) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Blackview
      # @ref:
      #########
      - regex: '; *(Crown) Build'
        device: 'Blackview $1'
        brand: 'Blackview'
        model: '$1'

      #########
      # Blaupunkt
      # @ref: http://www.blaupunkt.com
      #########
      # Endeavour
      - regex: '; *([0-9]+BP[EM][^;/]*|Endeavour[^;/]+) Build'
        device: 'Blaupunkt $1'
        brand: 'Blaupunkt'
        model: '$1'

      #########
      # Blu
      # @ref: http://bluproducts.com
      #########
      - regex: '; *((?:BLU|Blu)[ _\-])([^;/]+) Build'
        device: '$1$2'
        brand: 'Blu'
        model: '$2'
      # BMOBILE = operator branded device
      - regex: '; *(?:BMOBILE )?(Blu|(?:DASH|ADVANCE|VIVO|TANK) \d\.\d[^;/]*|STUDIO[^;/]+) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Blu'
        model: '$1'

      #########
      # Blusens
      # @ref: http://www.blusens.com/es/?sg=1&sv=al&roc=1
      #########
      # tablet
      - regex: '; *(TOUCH\d[^;/]+) Build'
        device: '$1'
        brand: 'Blusens'
        model: '$1'

      #########
      # Bmobile
      # @ref: http://bmobile.eu.com/?categoria=smartphones-2
      # @note: Might collide with Maxx as AX is used also there.
      #########
      # smartphone
      - regex: '; *(?:Bmobile[ _]+)?(AX[56]\d{2}|AX7[^0]\d) Build'
        device: 'Bmobile $1'
        brand: 'Bmobile'
        model: '$1'
        type: 'smartphone'

      #########
      # bq
      # @ref: http://bqreaders.com
      #########
      - regex: '; *([Bb]q)? ?(Aquaris[^;/]*);? Build'
        device: '$1 $2'
        brand: 'bq'
        model: '$2'
        type: 'smartphone'
      - regex: '; *([Bb]q) ([^;/]+);? Build'
        device: '$1 $2'
        brand: 'bq'
        model: '$2'
        type: 'tablet'
      - regex: '; *(Maxwell [^;/]+) Build'
        device: '$1'
        brand: 'bq'
        model: '$1'
        type: 'tablet'

      #########
      # Braun Phototechnik
      # @ref: http://www.braun-phototechnik.de/en/products/list/~pcat.250/Tablet-PC.html
      #########
      - regex: '; *((?:B-Tab|B-TAB) ?\d[^;/]+) Build'
        device: '$1'
        brand: 'Braun'
        model: '$1'

      #########
      # Broncho
      # @ref: http://www.broncho.cn/
      #########
      - regex: '; *(Broncho) ([^;/]+) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Brondi
      # @ref: https://www.brondi.it/smartphone.html
      #########
      - regex: '; *(Caesar|CENTURION(?:[ -]\d)?|CENTVRION2|GLADIATOR(?:[ -]\d)?|GLORY(?:[ -]\d)?|LUXURY(?:[ -]\d)?|SENSUELLE|VICTORY) Build'
        regex_flag: 'i'
        device: 'Brondi $1'
        brand: 'Brondi'
        model: '$1'

      #########
      # Captiva
      # @ref: http://www.captiva-power.de
      #########
      - regex: '; *CAPTIVA ([^;/]+) Build'
        device: 'Captiva $1'
        brand: 'Captiva'
        model: '$1'

      #########
      # Casio
      # @ref: http://www.casiogzone.com/
      #########
      - regex: '; *(C771|CAL21|IS11CA) Build'
        device: '$1'
        brand: 'Casio'
        model: '$1'

      #########
      # Cat
      # @ref: http://www.cat-sound.com
      #########
      - regex: '; *(?:Cat|CAT) ([^;/]+) Build'
        device: 'Cat $1'
        brand: 'Cat'
        model: '$1'
      - regex: '; *(B15Q?) Build'
        device: 'Cat $1'
        brand: 'Cat'
        model: '$1'
      - regex: '; *(?:Cat)(Nova.*) Build'
        device: 'Cat $1'
        brand: 'Cat'
        model: '$1'
      - regex: '; *(INM8002KP|ADM8000KP_[AB]) Build'
        device: '$1'
        brand: 'Cat'
        model: 'Tablet PHOENIX 8.1J0'

      #########
      # Celkon
      # @ref: http://www.celkonmobiles.com/?_a=products
      # @models: A10, A19Q, A101, A105, A107, A107\+, A112, A118, A119, A119Q, A15, A19, A20, A200, A220, A225, A22 Race, A27, A58, A59, A60, A62, A63, A64, A66, A67, A69, A75, A77, A79, A8\+, A83, A85, A86, A87, A89 Ultima, A9\+, A90, A900, A95, A97i, A98, AR 40, AR 45, AR 50, ML5
      #########
      - regex: '; *(?:[Cc]elkon[ _\*]|CELKON[ _\*])([^;/\)]+) ?(?:Build|;|\))'
        device: '$1'
        brand: 'Celkon'
        model: '$1'
      - regex: 'Build/(?:[Cc]elkon)+_?([^;/_\)]+)'
        device: '$1'
        brand: 'Celkon'
        model: '$1'
      - regex: '; *(CT)-?(\d+) Build'
        device: '$1$2'
        brand: 'Celkon'
        model: '$1$2'
      # smartphones
      - regex: '; *(A19|A19Q|A105|A107[^;/\)]*|A354C) ?(?:Build|;|\))'
        device: '$1'
        brand: 'Celkon'
        model: '$1'

      #########
      # ChangJia
      # @ref: http://www.cjshowroom.com/eproducts.aspx?classcode=004001001
      # @brief: China manufacturer makes tablets for different small brands
      #         (eg. http://www.zeepad.net/index.html)
      #########
      - regex: '; *(TPC[0-9]{4,5}) Build'
        device: '$1'
        brand: 'ChangJia'
        model: '$1'

      #########
      # Cloudfone
      # @ref: http://www.cloudfonemobile.com/
      #########
      - regex: '; *(Cloudfone)[ _](Excite)([^ ][^;/]+) Build'
        device: '$1 $2 $3'
        brand: 'Cloudfone'
        model: '$1 $2 $3'
      - regex: '; *(Excite|ICE)[ _](\d+[^;/]+) Build'
        device: 'Cloudfone $1 $2'
        brand: 'Cloudfone'
        model: 'Cloudfone $1 $2'
      - regex: '; *(Cloudfone|CloudPad)[ _]([^;/]+) Build'
        device: '$1 $2'
        brand: 'Cloudfone'
        model: '$1 $2'

      #########
      # Cmx
      # @ref: http://cmx.at/de/
      #########
      - regex: '; *((?:Aquila|Clanga|Rapax)[^;/]+) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Cmx'
        model: '$1'

      #########
      # CobyKyros
      # @ref: http://cobykyros.com
      # @note: Be careful with MID\d{3} from MpMan or Manta
      #########
      - regex: '; *(?:CFW-|Kyros )?(MID[0-9]{4}(?:[ABC]|SR|TV)?)(\(3G\)-4G| GB 8K| 3G| 8K| GB)? *(?:Build|[;\)])'
        device: 'CobyKyros $1$2'
        brand: 'CobyKyros'
        model: '$1$2'

      #########
      # Coolpad
      # @ref: ??
      #########
      - regex: '; *([^;/]*)Coolpad[ _]?([^;/]+) Build'
        device: '$1$2'
        brand: 'Coolpad'
        model: '$1$2'
      - regex: '; *(801E[MS]?) Build'
        device: '$1'
        brand: 'Coolpad'
        model: '$1'

      #########
      # Cube
      # @ref: http://www.cube-tablet.com/buy-products.html
      #########
      - regex: '; *(CUBE[ _])?([KU][0-9]+ ?GT.*|A5300) Build'
        regex_flag: 'i'
        device: '$1$2'
        brand: 'Cube'
        model: '$2'
        type: 'tablet'

      #########
      # Cubot
      # @ref: http://www.cubotmall.com/
      #########
      - regex: '; *CUBOT[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Cubot'
        model: '$1'
      - regex: '; *(BOBBY|GT[89]\d|P6|P7|P9|P10|S108|S168|S200|S208|S222|S308|s350|T9|X6|X9) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Cubot'
        model: '$1'

      #########
      # Danew
      # @ref: http://www.danew.com/produits-tablette.php
      #########
      - regex: '; *(Dslide ?[^;/]+) Build'
        device: '$1'
        brand: 'Danew'
        model: '$1'
        type: 'tablet'

      #########
      # Dell
      # @ref: http://www.dell.com
      # @ref: http://www.softbank.jp/mobile/support/product/101dl/
      # @ref: http://www.softbank.jp/mobile/support/product/001dl/
      # @ref: http://developer.emnet.ne.jp/android.html
      # @ref: http://www.dell.com/in/p/mobile-xcd28/pd
      # @ref: http://www.dell.com/in/p/mobile-xcd35/pd
      #########
      - regex: '; *(XCD)[ _]?(28|35) Build'
        device: 'Dell $1$2'
        brand: 'Dell'
        model: '$1$2'
      - regex: '; *(001DL) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: 'Streak'
      - regex: '; *(?:Dell|DELL) (Streak) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: 'Streak'
      - regex: '; *(101DL|GS01|Streak Pro[^;/]*) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: 'Streak Pro'
      - regex: '; *([Ss]treak ?7) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: 'Streak 7'
      - regex: '; *(Mini-3iX) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: '$1'
      - regex: '; *(?:Dell|DELL)[ _](Aero|Venue|Thunder|Mini.*|Streak[ _]Pro) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: '$1'
      - regex: '; *Dell[ _]([^;/]+) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: '$1'
      - regex: '; *Dell ([^;/]+) Build'
        device: 'Dell $1'
        brand: 'Dell'
        model: '$1'

      #########
      # Denver
      # @ref: http://www.denver-electronics.com/tablets1/
      #########
      - regex: '; *(?:PO#\d{4} )?(TA[CDQ]-\d+[^;/]*) Build'
        device: '$1'
        brand: 'Denver'
        model: '$1'
        type: 'tablet'

      #########
      # Dex
      # @ref: http://dex.ua/
      #########
      - regex: '; *(iP[789]\d{2}(?:-3G)?|IP10\d{2}(?:-8GB)?) Build'
        device: '$1'
        brand: 'Dex'
        model: '$1'

      #########
      # DNS AirTab
      # @ref: http://www.dns-shop.ru/
      #########
      - regex: '; *(AirTab)[ _\-]([^;/]+) Build'
        device: '$1 $2'
        brand: 'DNS'
        model: '$1 $2'

      #########
      # Docomo (Operator Branded Device)
      # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
      #########
      - regex: '; *(F\-\d[^;/]+) Build'
        device: '$1'
        brand: 'Fujitsu'
        model: '$1'
      - regex: '; *(HT-03A) Build'
        device: '$1'
        brand: 'HTC'
        model: 'Magic'
      - regex: '; *(HT\-\d[^;/]+) Build'
        device: '$1'
        brand: 'HTC'
        model: '$1'
      - regex: '; *(L\-\d[^;/]+) Build'
        device: '$1'
        brand: 'LG'
        model: '$1'
      - regex: '; *(N\-\d[^;/]+) Build'
        device: '$1'
        brand: 'Nec'
        model: '$1'
      - regex: '; *(P\-\d[^;/]+) Build'
        device: '$1'
        brand: 'Panasonic'
        model: '$1'
      - regex: '; *(SC\-\d[^;/]+) Build'
        device: '$1'
        brand: 'Samsung'
        model: '$1'
      - regex: '; *(SH\-\d[^;/]+) Build'
        device: '$1'
        brand: 'Sharp'
        model: '$1'
      - regex: '; *(SO\-\d[^;/]+) Build'
        device: '$1'
        brand: 'SonyEricsson'
        model: '$1'
      - regex: '; *(T\-0[12][^;/]+) Build'
        device: '$1'
        brand: 'Toshiba'
        model: '$1'

      #########
      # Doogee
      # @ref: http://www.doogeemobile.com/
      #########
      - regex: '; *(?:DOOGEE[ -]([^;/]+)|([^;/]+[ -]DG\d{3,4}[A-Z]?)|(DG800));? +Build'
        device: '$1$2$3'
        brand: 'Doogee'
        model: '$1$2$3'

      #########
      # Doro
      # @ref: http://doro.com
      #########
      - regex: '; *Doro (.*?) Build'
        device: '$1'
        brand: 'Doro'
        model: '$1'

      #########
      # DOOV
      # @ref: http://www.doov.com.cn/
      #########
      - regex: '; *(DOOV)[ _]([^;/]+) Build'
        device: '$1 $2'
        brand: 'DOOV'
        model: '$2'

      #########
      # Elephone
      # @ref: http://www.elephone.hk/
      #########
      - regex: '; *(Elephone)[ -]?([^;/]+) Build'
        device: '$1'
        brand: 'Elephone'
        model: '$2$3'

      #########
      # Enot
      # @ref: http://www.enot.ua/
      #########
      - regex: '; *(Enot|ENOT)[ -]?([^;/]+) Build'
        device: '$1 $2'
        brand: 'Enot'
        model: '$2'

      #########
      # Evercoss
      # @ref: http://evercoss.com/android/
      #########
      - regex: '; *[^;/]+ Build/(?:CROSS|Cross)+[ _\-]([^\)]+)'
        device: 'CROSS $1'
        brand: 'Evercoss'
        model: 'Cross $1'
      - regex: '; *(CROSS|Cross)[ _\-]([^;/]+) Build'
        device: '$1 $2'
        brand: 'Evercoss'
        model: 'Cross $2'
      - regex: '; *(A7[STV].?|A10Q|A26[BC]|A28[BMS]|A33A|A5C|A5[ST]|A65A|A66[AB]|A7E|A80A|AT1[ACG]\*?) Build'
        device: '$1'
        brand: 'Evercoss'
        model: '$1'

      #########
      # Explay
      # @ref: http://explay.ru/
      #########
      - regex: '; *Explay[_ ](.+?)(?:[\)]| Build)'
        device: '$1'
        brand: 'Explay'
        model: '$1'

      #########
      # Fairphone
      # @ref: https://www.fairphone.com/
      #########
      - regex: '; *(FP1|FP1U) Build'
        device: '$1'
        brand: 'Fairphone'
        model: '$1'

      #########
      # Fly
      # @ref: http://www.fly-phone.com/
      #########
      - regex: '; *(IQ.*) Build'
        device: '$1'
        brand: 'Fly'
        model: '$1'
      - regex: '; *(Fly|FLY)[ _](IQ[^;]+|F[34]\d+[^;]*|Phoenix 2);? Build'
        device: '$1 $2'
        brand: 'Fly'
        model: '$2'

      #########
      # Fujitsu
      # @ref: http://www.fujitsu.com/global/
      #########
      - regex: '; *(M532|Q572|FJL21) Build/'
        device: '$1'
        brand: 'Fujitsu'
        model: '$1'

      #########
      # Galapad
      # @ref: http://www.galapad.net/product.html
      #########
      - regex: '; *(G1) Build'
        device: '$1'
        brand: 'Galapad'
        model: '$1'

      #########
      # Geeksphone
      # @ref: http://www.geeksphone.com/
      #########
      - regex: '; *(Geeksphone) ([^;/]+) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Gfive
      # @ref: http://www.gfivemobile.com/en
      #########
      #- regex: '; *(G\'?FIVE) ([^;/]+) Build' # there is a problem with python yaml parser here
      - regex: '; *(G[^F]?FIVE) ([^;/]+) Build'
        device: '$1 $2'
        brand: 'Gfive'
        model: '$2'
      - regex: '; *(A5\(GOL\)) Build'
        device: '$1'
        brand: 'Gfive'
        model: '$1'

      #########
      # Gionee
      # @ref: http://www.gionee.com/
      #########
      - regex: '; *(Gionee)[ _\-]([^;/]+)(?:/[^;/]+)? Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Gionee'
        model: '$2'
      - regex: '; *(GN\d+[A-Z]?|INFINITY_PASSION|Ctrl_V1|Pioneer_P[123]S?|P4S?|S5\.[15]) Build'
        device: 'Gionee $1'
        brand: 'Gionee'
        model: '$1'
      - regex: '; *(E3|E7) Build/J'
        device: 'Gionee $1'
        brand: 'Gionee'
        model: '$1'

      #########
      # GoClever
      # @ref: http://www.goclever.com
      #########
      - regex: '; *((?:FONE|QUANTUM|INSIGNIA|ARIES)[ _]\d+[^;/]*|PLAYTAB) Build'
        device: 'GoClever $1 $2'
        brand: 'GoClever'
        model: '$1 $2'
      - regex: '; *GOCLEVER ([^;/]+) Build'
        device: 'GoClever $1'
        brand: 'GoClever'
        model: '$1'

      #########
      # Google
      # @ref: http://www.google.de/glass/start/
      #########
      - regex: '; *(Glass \d+) Build'
        device: '$1'
        brand: 'Google'
        model: '$1'

      #########
      # Gigabyte
      # @ref: http://gsmart.gigabytecm.com/en/
      #########
      - regex: '; *(GSmart)[ -]([^/]+) Build'
        device: '$1 $2'
        brand: 'Gigabyte'
        model: '$1 $2'

      #########
      # Gigaset
      # @ref: http://www.gigaset.com/
      #########
      - regex: '; *(Gigaset)[ ]([^/]+) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      - regex: '; *(SL930[^/]*) Build'
        device: 'Gigaset $1'
        brand: 'Gigaset'
        model: '$1'

      #########
      # G-Tide
      # @ref: http://www.g-tidemobile.com
      #########
      - regex: '; *(G-TiDE)[ ]([^/]+) Build'
        regex_flag: i
        device: 'G-Tide $2'
        brand: 'G-Tide'
        model: '$2'

      #########
      # Freescale development boards
      # @ref: http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=IMX53QSB
      #########
      - regex: '; *(imx5[13]_[^/]+) Build'
        device: 'Freescale $1'
        brand: 'Freescale'
        model: '$1'

      #########
      # Haier
      # @ref: http://www.haier.com/
      # @ref: http://www.haier.com/de/produkte/tablet/
      #########
      - regex: '; *Haier[ _\-]([^/]+) Build'
        device: 'Haier $1'
        brand: 'Haier'
        model: '$1'
      - regex: '; *(HW-[^/]+|W867) Build'
        device: 'Haier $1'
        brand: 'Haier'
        model: '$1'
        type: 'smartphone'
      - regex: '; *(PAD1016) Build'
        device: 'Haier $1'
        brand: 'Haier'
        model: '$1'
        type: 'tablet'

      #########
      # Haipad
      # @ref: http://www.haipad.net/
      # @models: V7P|M7SM7S|M9XM9X|M7XM7X|M9|M8|M7-M|M1002|M7|M701
      #########
      - regex: '; *(M701|M7|M8|M9) Build'
        device: 'Haipad $1'
        brand: 'Haipad'
        model: '$1'

      #########
      # Hannspree
      # @ref: http://www.hannspree.eu/
      #########
      - regex: '; *(SN\d+T[^;\)/]*|HSG12\d+)(?: Build|[;\)])'
        device: 'Hannspree $1'
        brand: 'Hannspree'
        model: '$1'

      #########
      # HCLme
      # @ref: http://www.hclmetablet.com/india/
      #########
      - regex: 'Build/HCL ME Tablet ([^;\)]+)[\);]'
        device: 'HCLme $1'
        brand: 'HCLme'
        model: '$1'
      - regex: '; *([^;\/]+) Build/HCL'
        device: 'HCLme $1'
        brand: 'HCLme'
        model: '$1'

      #########
      # Hena
      # @ref: http://www.henadigital.com/en/product/index.asp?id=6
      #########
      - regex: '; *(MID-?\d{4}C[EM]) Build'
        device: 'Hena $1'
        brand: 'Hena'
        model: '$1'

      #########
      # Hisense
      # @ref: http://www.hisense.com/
      #########
      - regex: '; *(EG\d{2,}|HS-[^;/]+|MIRA[^;/]+|AD683G) Build'
        device: 'Hisense $1'
        brand: 'Hisense'
        model: '$1'
      - regex: '; *(andromax[^;/]+) Build'
        regex_flag: 'i'
        device: 'Hisense $1'
        brand: 'Hisense'
        model: '$1'

      #########
      # hitech
      # @ref: http://www.hitech-mobiles.com/
      #########
      - regex: '; *(?:AMAZE[ _](S\d+)|(S\d+)[ _]AMAZE) Build'
        device: 'AMAZE $1$2'
        brand: 'hitech'
        model: 'AMAZE $1$2'

      #########
      # HP
      # @ref: http://www.hp.com/
      #########
      - regex: '; *(PlayBook|Slate \d+(?: Pro)?) Build'
        device: 'HP $1'
        brand: 'HP'
        model: '$1'
      - regex: '; *HP ([^/]+) Build'
        device: 'HP $1'
        brand: 'HP'
        model: '$1'
      - regex: '; *([^/]+_tenderloin) Build'
        device: 'HP TouchPad'
        brand: 'HP'
        model: 'TouchPad'

      #########
      # HTC
      # @ref: http://www.htc.com/www/products/
      # @ref: http://en.wikipedia.org/wiki/List_of_HTC_phones
      #########
      - regex: 'USCCHTC(\d+)'
        brand: 'HTC'
        model: '$1'
      - regex: 'USCC(ADR\d+)'
        brand: 'HTC'
        model: '$1'
      # Android HTC with Version Number matcher
      # ; HTC_0P3Z11/1.12.161.3 Build
      # ;HTC_A3335 V2.38.841.1 Build
      - regex: '; *(?:HTC)(?:[ _/]((?:(?![ _/;\(\)]|Build|MIUI).)+))(?:[ _/]((?:(?![ _/;\(\)]|HTC|Build|MIUI).)+))?(?:[ _/]((?:(?![ _/;\(\)]|Build|MIUI).)+))?(?:[ _/]((?:(?![/;\)]|Build|MIUI).)+))?(?:[/\\]1\.0 | V|/| +)\d+\.\d[\d\.]+'
        device: 'HTC $1 $2 $3 $4'
        brand: 'HTC'
        model: '$1 $2 $3 $4'
      # Android HTC without Version Number matcher
      - regex: '; *(?:HTC[ ;])?(?:HTC(?:_blocked)*)(?:(?:[ _/]|; *)((?:(?![ _/;\(\)\\]|USCCHTC|HTC|Build|MIUI).)+))(?:[ _/]((?:(?![ _/;\(\)\\]|Build|MIUI|1\.0).)+))?(?:[ _/]((?:(?![ _/;\(\)\\]|Build|MIUI|1\.0).)+))?(?:[ _/]((?:(?![/;\)]|Build|MIUI|1\.0).)+))?'
        regex_flag: 'i'
        device: 'HTC $1 $2 $3 $4'
        brand: 'HTC'
        model: '$1 $2 $3 $4'
      # HTC Streaming Player
      - regex: 'HTC Streaming Player [^\/]*/[^\/]*/ htc_([^/]+) /'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'
      # general matcher for anything else
      - regex: '(?:[;,] *|^)(?:htccn_chs-)?HTC[ _-]?([^;]+?)(?: *Build|clay|Android|-?Mozilla| Opera| Profile| UNTRUSTED|[;/\(\)]|$)'
        regex_flag: 'i'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'
      # Android matchers without HTC
      - regex: '; *(0PAJ5|0PCV1|A320a|Z520m|HTL22|801a|A6277|ADR6200|ADR63[03]0[A-Z]*|ADR6350|ADR64[01]0[A-Z]*|ADR6425[A-Z]*|APX515CKT|Desire[^_ ]*|Dream|EndeavorU|Eris|Evo|Flyer|HD2|Hero|HERO200|Hero CDMA|HTL21|Incredible|Inspire[A-Z0-9]*|Legend|Liberty|Nexus ?(?:One|HD2)|Nexus 9|One|One S C2|One[ _]?(?:M|S|V|X\+?)\w*|PC36100|PG06100|PG86100|PJ83100|PM63100|S31HT|Sensation|Wildfire)(?: Build|[/;\(\)])'
        regex_flag: 'i'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'
      - regex: '; *(ADR6200|ADR6400L|ADR64(?:10|25|)LVW|Amaze|DesireS?|EndeavorU|Eris|EVO|Evo\d[A-Z]+|HD2|IncredibleS?|Inspire[A-Z0-9]*|Inspire[A-Z0-9]*|Sensation[A-Z0-9]*|Wildfire)[ _-](.+?)(?:[/;\)]|Build|MIUI|1\.0)'
        regex_flag: 'i'
        device: 'HTC $1 $2 $3 $4'
        brand: 'HTC'
        model: '$1 $2 $3 $4'

      #########
      # Hyundai
      # @ref: http://www.hyundaitechnologies.com
      #########
      - regex: '; *HYUNDAI (T\d[^/]*) Build'
        device: 'Hyundai $1'
        brand: 'Hyundai'
        model: '$1'
      - regex: '; *HYUNDAI ([^;/]+) Build'
        device: 'Hyundai $1'
        brand: 'Hyundai'
        model: '$1'
      # X900? http://www.amazon.com/Hyundai-X900-Retina-Android-Bluetooth/dp/B00AO07H3O
      - regex: '; *(X700|Hold X|MB-6900) Build'
        device: 'Hyundai $1'
        brand: 'Hyundai'
        model: '$1'

      #########
      # iBall
      # @ref: http://www.iball.co.in/Category/Mobiles/22
      #########
      - regex: '; *(?:iBall[ _\-])?(Andi)[ _]?(\d[^;/]*|Uddaan) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'iBall'
        model: '$1 $2'
      - regex: '; *(IBall)(?:[ _]([^;/]+)|) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'iBall'
        model: '$2'
      - regex: '; * (3G 7271-HD70) Build'
        device: '$1'
        brand: 'iBall'
        model: '$1'

      #########
      # IconBIT
      # @ref: http://www.iconbit.com/catalog/tablets/
      #########
      - regex: '; *(NT-\d+[^ ;/]*|Net[Tt]AB [^;/]+|Mercury [A-Z]+|iconBIT)(?: S/N:[^;/]+)? Build'
        device: '$1'
        brand: 'IconBIT'
        model: '$1'

      #########
      # IMO
      # @ref: http://www.ponselimo.com/
      #########
      - regex: '; *(IMO)[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'IMO'
        model: '$2'

      #########
      # i-mobile
      # @ref: http://www.i-mobilephone.com/
      #########
      - regex: '; *i-?mobile[ _]([^/]+) Build/'
        regex_flag: 'i'
        device: 'i-mobile $1'
        brand: 'imobile'
        model: '$1'
      - regex: '; *(i-(?:style|note)[^/]*) Build/'
        regex_flag: 'i'
        device: 'i-mobile $1'
        brand: 'imobile'
        model: '$1'

      #########
      # Impression
      # @ref: http://impression.ua/planshetnye-kompyutery
      #########
      - regex: '; *(ImPAD) ?(\d+(?:.)*) Build'
        device: '$1 $2'
        brand: 'Impression'
        model: '$1 $2'

      #########
      # Infinix
      # @ref: http://www.infinixmobility.com/index.html
      #########
      - regex: '; *(Infinix)[ _]([^;/]+) Build'
        device: '$1 $2'
        brand: 'Infinix'
        model: '$2'

      #########
      # InFocus
      # @ref:
      #########
      - regex: '; *(InFocus)[ _]([^;/]+) Build'
        device: '$1 $2'
        brand: 'InFocus'
        model: '$2'

      #########
      # Informer
      # @ref: ??
      #########
      - regex: '; *(Informer)[ \-]([^;/]+) Build'
        device: '$1 $2'
        brand: 'Informer'
        model: '$2'

      #########
      # Intenso
      # @ref: http://www.intenso.de
      # @models: 7":TAB 714,TAB 724;8":TAB 814,TAB 824;10":TAB 1004
      #########
      - regex: '; *(TAB) ?([78][12]4) Build'
        device: 'Intenso $1'
        brand: 'Intenso'
        model: '$1 $2'

      #########
      # Intex
      # @ref: http://intexmobile.in/index.aspx
      # @note: Zync also offers a "Cloud Z5" device
      #########
      # smartphones
      - regex: '; *(?:Intex[ _])?(AQUA|Aqua)([ _\.\-])([^;/]+) *(?:Build|;)'
        device: '$1$2$3'
        brand: 'Intex'
        model: '$1 $3'
      - regex: '; *(Auqa Xtreme) *(?: Build|;)'
        device: '$1$2$3'
        brand: 'Intex'
        model: '$1 $3'

      # matches "INTEX CLOUD X1"
      - regex: '; *(?:INTEX|Intex)(?:[_ ]([^\ _;/]+))(?:[_ ]([^\ _;/]+))? *(?:Build|;)'
        device: '$1 $2'
        brand: 'Intex'
        model: '$1 $2'
      # tablets
      - regex: '; *([iI]Buddy)[ _]?(Connect)(?:_|\?_| )?([^;/]*) *(?:Build|;)'
        device: '$1 $2 $3'
        brand: 'Intex'
        model: 'iBuddy $2 $3'
      - regex: '; *(I-Buddy)[ _]([^;/]+) *(?:Build|;)'
        device: '$1 $2'
        brand: 'Intex'
        model: 'iBuddy $2'

      #########
      # iOCEAN
      # @ref: http://www.iocean.cc/
      #########
      - regex: '; *(iOCEAN) ([^/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'iOCEAN'
        model: '$2'

      #########
      # i.onik
      # @ref: http://www.i-onik.de/
      #########
      - regex: '; *(TP\d+(?:\.\d+)?\-\d[^;/]+|TU-\d{4}A) Build'
        device: 'ionik $1'
        brand: 'ionik'
        model: '$1'
        type: 'tablet'

      #########
      # IRU.ru
      # @ref: http://www.iru.ru/catalog/soho/planetable/
      #########
      - regex: '; *(M702pro) Build'
        device: '$1'
        brand: 'Iru'
        model: '$1'

      #########
      # Ivio
      # @ref: http://www.ivio.com/mobile.php
      # @models: DG80,DG20,DE38,DE88,MD70
      #########
      - regex: '; *(DE88Plus|MD70) Build'
        device: '$1'
        brand: 'Ivio'
        model: '$1'
      - regex: '; *IVIO[_\-]([^;/]+) Build'
        device: '$1'
        brand: 'Ivio'
        model: '$1'

      #########
      # Jaytech
      # @ref: http://www.jay-tech.de/jaytech/servlet/frontend/
      #########
      - regex: '; *(TPC[-_](?:PA|PX)?[\d\.]+[A-Z]?|JAY-TECH) Build'
        device: '$1'
        brand: 'Jaytech'
        model: '$1'

      #########
      # Jiayu
      # @ref: http://www.ejiayu.com/en/Product.html
      #########
      - regex: '; *(JY-[^;/]+|G[234]S?) Build'
        device: '$1'
        brand: 'JiaYu'
        model: '$1'

      #########
      # JXD
      # @ref: http://www.jxd.hk/
      #########
      - regex: '; *(JXD)[ _\-]([^;/]+) Build'
        device: '$1 $2'
        brand: 'JXD'
        model: '$2'

      #########
      # Karbonn
      # @ref: http://www.karbonnmobiles.com/products_tablet.php
      #########
      - regex: '; *Karbonn[ _]?([^;/]+) *(?:Build|;)'
        regex_flag: 'i'
        device: '$1'
        brand: 'Karbonn'
        model: '$1'
      - regex: '; *([^;]+) Build/Karbonn'
        device: '$1'
        brand: 'Karbonn'
        model: '$1'
      - regex: '; *(A\d{1,2}(?:\+| Plus)|A[13679]|A1\d|A5 Turbo|A6 Turbo|A7\*|A34|A37|A39|A99[\*i]|ST8|ST10|ST7|Smart Tab3|Smart Tab2|Sparkle V|Titanium S\d+[^;/]*|Titanium Octane[^;/]*) +Build(?:(?!QMobile).)*$'
        device: '$1'
        brand: 'Karbonn'
        model: '$1'

      #########
      # Kazam
      # @ref: https://www.kazam.mobi/
      #########
      - regex: '; *Kazam ([^;/]+) *(?:Build|;)'
        regex_flag: 'i'
        device: '$1'
        brand: 'Kazam'
        model: '$1'
      - regex: '; *(Tornado \d+|Trooper[^;/]+) *(?:Build|;)'
        regex_flag: 'i'
        device: '$1'
        brand: 'Kazam'
        model: '$1'

      #########
      # KDDI (Operator Branded Device)
      # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
      #########
      - regex: 'ISW?\d|INFOBAR'
        group:
          - regex: '; *(IS01|IS03|IS05|IS\d{2}SH) Build'
            device: '$1'
            brand: 'Sharp'
            model: '$1'
          - regex: '; *(IS04) Build'
            device: '$1'
            brand: 'Regza'
            model: '$1'
          - regex: '; *(IS06|IS\d{2}PT) Build'
            device: '$1'
            brand: 'Pantech'
            model: '$1'
          - regex: '; *(IS11S) Build'
            device: '$1'
            brand: 'SonyEricsson'
            model: 'Xperia Acro'
          - regex: '; *(IS11CA) Build'
            device: '$1'
            brand: 'Casio'
            model: 'GzOne $1'
          - regex: '; *(IS11LG) Build'
            device: '$1'
            brand: 'LG'
            model: 'Optimus X'
          - regex: '; *(IS11N) Build'
            device: '$1'
            brand: 'Medias'
            model: '$1'
          - regex: '; *(IS11PT) Build'
            device: '$1'
            brand: 'Pantech'
            model: 'MIRACH'
          - regex: '; *(IS12F) Build'
            device: '$1'
            brand: 'Fujitsu'
            model: 'Arrows ES'
          # @ref: https://ja.wikipedia.org/wiki/IS12M
          - regex: '; *(IS12M) Build'
            device: '$1'
            brand: 'Motorola'
            model: 'XT909'
          - regex: '; *(IS12S) Build'
            device: '$1'
            brand: 'SonyEricsson'
            model: 'Xperia Acro HD'
          - regex: '; *(ISW11F) Build'
            device: '$1'
            brand: 'Fujitsu'
            model: 'Arrowz Z'
          - regex: '; *(ISW11HT) Build'
            device: '$1'
            brand: 'HTC'
            model: 'EVO'
          - regex: '; *(ISW11K) Build'
            device: '$1'
            brand: 'Kyocera'
            model: 'DIGNO'
          - regex: '; *(ISW11M) Build'
            device: '$1'
            brand: 'Motorola'
            model: 'Photon'
          - regex: '; *(ISW11SC) Build'
            device: '$1'
            brand: 'Samsung'
            model: 'GALAXY S II WiMAX'
          - regex: '; *(ISW12HT) Build'
            device: '$1'
            brand: 'HTC'
            model: 'EVO 3D'
          - regex: '; *(ISW13HT) Build'
            device: '$1'
            brand: 'HTC'
            model: 'J'
          - regex: '; *(ISW?[0-9]{2}[A-Z]{0,2}) Build'
            device: '$1'
            brand: 'KDDI'
            model: '$1'
          - regex: '; *(INFOBAR [^;/]+) Build'
            device: '$1'
            brand: 'KDDI'
            model: '$1'

      #########
      # Kiano
      # @ref: http://elegance.kiano.pl/en/
      #########
      - regex: '; *Kiano ?([^;/]+) Build/'
        regex_flag: 'i'
        device: '$1'
        brand: 'Kiano'
        model: '$1'

      #########
      # Kingcom
      # @ref: http://www.e-kingcom.com
      #########
      - regex: '; *(JOYPAD|Joypad)[ _]([^;/]+) Build/'
        device: '$1 $2'
        brand: 'Kingcom'
        model: '$1 $2'

      #########
      # Kobo
      # @ref: https://en.wikipedia.org/wiki/Kobo_Inc.
      # @ref: http://www.kobo.com/devices#tablets
      #########
      - regex: '; *(Vox|VOX|Arc|arc 7|K080) Build/'
        regex_flag: 'i'
        device: '$1'
        brand: 'Kobo'
        model: '$1'
      - regex: '\b(Kobo Touch)\b'
        device: '$1'
        brand: 'Kobo'
        model: '$1'

      #########
      # K-Touch
      # @ref: ??
      #########
      - regex: '; *(K-Touch)[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Ktouch'
        model: '$2'

      #########
      # KT Tech
      # @ref: http://www.kttech.co.kr
      #########
      - regex: '; *((?:EV|KM)-S\d+[A-Z]?) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'KTtech'
        model: '$1'

      #########
      # Kyocera
      # @ref: http://www.android.com/devices/?country=all&m=kyocera
      #########
      - regex: '; *(Zio|Hydro|Torque|Event|EVENT|Echo|Milano|Rise|URBANO PROGRESSO|WX04K|WX06K|WX10K|KYL21|[12]0[12]K|302KC|C5[12]\d{2}|E6782) Build/'
        device: '$1'
        brand: 'Kyocera'
        model: '$1'

      #########
      # Landvo
      # @ref: http://www.kimovil.com/en/landvo-smartphones-prices
      #########
      - regex: '; *(L\d{3}[A-Z]?) *(?:;|\)|Build)'
        device: '$1'
        brand: 'Landvo'
        model: '$1'

      #########
      # Lava
      # @ref: http://www.lavamobiles.com/
      #########
      - regex: '; *(?:LAVA[ _])?IRIS[ _\-]?([^/;\)]+) *(?:;|\)|Build)'
        regex_flag: 'i'
        device: 'Iris $1'
        brand: 'Lava'
        model: 'Iris $1'
      - regex: '; *LAVA[ _]([^;/]+) Build'
        device: '$1'
        brand: 'Lava'
        model: '$1'
      - regex: '; *(X604|504Q\+) Build'
        device: '$1'
        brand: 'Lava'
        model: '$1'

      #########
      # Leagoo
      # @ref: http://www.leagoo.cc/cs-mobile.html
      #########
      - regex: '; *(Lead [^;/]+) Build'
        regex_flag: 'i'
        device: 'Leagoo $1'
        brand: 'Leagoo'
        model: '$1'

      #########
      # Lemon
      # @ref: http://www.lemonmobiles.com/products.php?type=1
      #########
      - regex: '; *(?:(Aspire A1)|(?:LEMON|Lemon)[ _]([^;/]+))_? Build'
        device: 'Lemon $1$2'
        brand: 'Lemon'
        model: '$1$2'

      #########
      # Lenco
      # @ref: http://www.lenco.com/c/tablets/
      #########
      - regex: '; *(TAB-1012) Build/'
        device: 'Lenco $1'
        brand: 'Lenco'
        model: '$1'
      - regex: '; Lenco ([^;/]+) Build/'
        device: 'Lenco $1'
        brand: 'Lenco'
        model: '$1'

      #########
      # Lenovo
      # @ref: http://support.lenovo.com/en_GB/downloads/default.page?#
      #########
      - regex: '; *(A1_07|A2107A-H|S2005A-H|S1-37AH0) Build'
        device: '$1'
        brand: 'Lenovo'
        model: '$1'
      - regex: '; *(Idea(?:Tab|[Pp]ad)|YOGA)[ _]?([^;/]+)[;]? Build'
        device: 'Lenovo $1 $2'
        brand: 'Lenovo'
        model: '$1 $2'
        type: 'tablet'
      - regex: '; *(ThinkPad) ?(Tablet) Build/'
        device: 'Lenovo $1 $2'
        brand: 'Lenovo'
        model: '$1 $2'
        type: 'tablet'
      - regex: '; *(?:LNV-)?(?:=?[Ll]enovo[ _\-]?|LENOVO[ _])+(.+?)(?:Build|[;/\)])'
        device: 'Lenovo $1'
        brand: 'Lenovo'
        model: '$1'
      - regex: '[;,] (?:Vodafone )?(SmartTab) ?(II) ?(\d+) Build/'
        device: 'Lenovo $1 $2 $3'
        brand: 'Lenovo'
        model: '$1 $2 $3'
        type: 'tablet'
      - regex: '; *(3GC101|3GW10[01]|A390|A3000|A680|A850|A880) Build/'
        device: '$1'
        brand: 'Lenovo'
        model: '$1'
      - regex: '\b(?:Lenovo|LENOVO)+[ _\-]?([^,;:/ ]+)'
        device: 'Lenovo $1'
        brand: 'Lenovo'
        model: '$1'

      #########
      # Lexibook
      # @ref: http://www.lexibook.com/fr
      #########
      - regex: '; *(MFC\d+)[A-Z]{2}([^;,/]*),? Build'
        device: '$1$2'
        brand: 'Lexibook'
        model: '$1$2'

      #########
      # LG
      # @ref: http://www.lg.com/uk/mobile
      #########
      - regex: '; *(Ally|AS\d{3}(?: 4G)?|E[34][0-9]{2}|LS[6-8][0-9]{2}|VS[6-9][0-9]+[^;/]+|Nexus [45]|Nexus 5X|GT540f?|Optimus (?:2X|G|4X HD)|OptimusX4HD) *(?:Build|;)'
        device: '$1'
        brand: 'LG'
        model: '$1'
      - regex: '[;:] *(L-\d+[A-Z]|LGL\d+[A-Z]?)(?:/V\d+)? *(?:Build|[;\)])'
        device: '$1'
        brand: 'LG'
        model: '$1'
      - regex: '; *(LG-)([A-Z]{1,2}\d{2,}[^,;/\)\(]*?)(?:Build| V\d+|[,;/\)\(]|$)'
        device: '$1$2'
        brand: 'LG'
        model: '$2'
      - regex: '; *(LG[ \-]|LG)([^;/]+)[;/]? Build'
        device: '$1$2'
        brand: 'LG'
        model: '$2'
      - regex: '^(LG)-([^;/]+)/ Mozilla/.*; Android'
        device: '$1 $2'
        brand: 'LG'
        model: '$2'

      #########
      # Malata
      # @ref: http://www.malata.com/en/products.aspx?classid=680
      #########
      - regex: '; *((?:SMB|smb)[^;/]+) Build/'
        device: '$1'
        brand: 'Malata'
        model: '$1'
      - regex: '; *(?:Malata|MALATA) ([^;/]+) Build/'
        device: '$1'
        brand: 'Malata'
        model: '$1'

      #########
      # Manta
      # @ref: http://www.manta.com.pl/en
      #########
      - regex: '; *(MS[45][0-9]{3}|MID0[568][NS]?|MID[1-9]|MID[78]0[1-9]|MID970[1-9]|MID100[1-9]) Build/'
        device: '$1'
        brand: 'Manta'
        model: '$1'

      #########
      # Match
      # @ref: http://www.match.net.cn/products.asp
      #########
      - regex: '; *(M1052|M806|M9000|M9100|M9701|MID100|MID120|MID125|MID130|MID135|MID140|MID701|MID710|MID713|MID727|MID728|MID731|MID732|MID733|MID735|MID736|MID737|MID760|MID800|MID810|MID820|MID830|MID833|MID835|MID860|MID900|MID930|MID933|MID960|MID980) Build/'
        device: '$1'
        brand: 'Match'
        model: '$1'

      #########
      # Maxx
      # @ref: http://www.maxxmobile.in/
      # @models: Maxx MSD7-Play, Maxx MX245+ Trance, Maxx AX8 Race, Maxx MSD7 3G- AX50, Maxx Genx Droid 7 - AX40, Maxx AX5 Duo,
      #   Maxx AX3 Duo, Maxx AX3, Maxx AX8 Note II (Note 2), Maxx AX8 Note I, Maxx AX8, Maxx AX5 Plus, Maxx MSD7 Smarty,
      #   Maxx AX9Z Race,
      #   Maxx MT150, Maxx MQ601, Maxx M2020, Maxx Sleek MX463neo, Maxx MX525, Maxx MX192-Tune, Maxx Genx Droid 7 AX353,
      # @note: Need more User-Agents!!!
      #########
      - regex: '; *(GenxDroid7|MSD7.*|AX\d{1,2}(?:[A-Z][A-z]*)?|Tab 701|Tab 722) Build/'
        device: 'Maxx $1'
        brand: 'Maxx'
        model: '$1'

      #########
      # Mediacom
      # @ref: http://www.mediacomeurope.it/
      #########
      - regex: '; *(M-PP[^;/]+|PhonePad ?\d{2,}[^;/]+) Build'
        device: 'Mediacom $1'
        brand: 'Mediacom'
        model: '$1'
      - regex: '; *(M-MP[^;/]+|SmartPad ?\d{2,}[^;/]+) Build'
        device: 'Mediacom $1'
        brand: 'Mediacom'
        model: '$1'

      #########
      # Medion
      # @ref: http://www.medion.com/en/
      #########
      - regex: '; *(?:MD_)?LIFETAB[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: 'Medion Lifetab $1'
        brand: 'Medion'
        model: 'Lifetab $1'
      - regex: '; *MEDION ([^;/]+) Build'
        device: 'Medion $1'
        brand: 'Medion'
        model: '$1'
      - regex: '; *(E4001|E4004) Build'
        device: 'Medion $1'
        brand: 'Medion'
        model: '$1'

      #########
      # Meizu
      # @ref: http://www.meizu.com
      #########
      - regex: '; *(M030|M031|M035|M040|M065|m9) Build'
        device: 'Meizu $1'
        brand: 'Meizu'
        model: '$1'
      - regex: '; *(?:meizu_|MEIZU )(.+?) *(?:Build|[;\)])'
        device: 'Meizu $1'
        brand: 'Meizu'
        model: '$1'

      #########
      # Micromax
      # @ref: http://www.micromaxinfo.com
      #########
      - regex: '\b(?:Micromax[ _\-]?)+(P[A-Za-z0-9]+)'
        regex_flag: 'i'
        device: 'Micromax $1'
        brand: 'Micromax'
        model: '$1'
      - regex: '\b(?:Micromax[ _\-]?)+([A-Za-z0-9]+)'
        regex_flag: 'i'
        device: 'Micromax $1'
        brand: 'Micromax'
        model: '$1'
      # be carefull here with Acer e.g. A500
      - regex: '; *(A[02-9]\d|A[12]\d{2}|A90S|A110Q|X505|A068) Build(?:(?!QMobile).)*$'
        regex_flag: 'i'
        device: 'Micromax $1'
        brand: 'Micromax'
        model: '$1'
      - regex: '; *(P\d{3}|P\d{3})(?:\(Funbook\))? Build'
        regex_flag: 'i'
        device: 'Micromax $1'
        brand: 'Micromax'
        model: '$1'

      #########
      # Mito
      # @ref: http://new.mitomobile.com/
      #########
      - regex: '; *(MITO)[ _\-]?([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Mito'
        model: '$2'

      #########
      # Mobistel
      # @ref: http://www.mobistel.com/
      #########
      - regex: '; *(Cynus)[ _](F5|T\d|.+?) *(?:Build|[;/\)])'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Mobistel'
        model: '$1 $2'

      #########
      # Mobiwire
      # @ref: http://mobiwire.com/
      #########
      - regex: '; *(Ahiga|Auriga[^;]*|Pegasus) *(?:Build|[;/\)])'
        device: '$1'
        brand: 'Mobiwire'
        model: '$1'

      #########
      # Modecom
      # @ref: http://www.modecom.eu/tablets/portal/
      #########
      - regex: '; *(MODECOM )?(FreeTab) ?([^;/]+) Build'
        regex_flag: 'i'
        device: '$1$2 $3'
        brand: 'Modecom'
        model: '$2 $3'
      - regex: '; *(MODECOM )([^;/]+) Build'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Modecom'
        model: '$2'

      #########
      # Motorola
      # @ref: http://www.motorola.com/us/shop-all-mobile-phones/
      #########
      - regex: '; *(MZ\d{3}\+?|MZ\d{3} 4G|Xoom[^;/]*|XOOM[^;/]*|RAZR HD) Build'
        device: 'Motorola $1'
        brand: 'Motorola'
        model: '$1'
      - regex: '; *(Milestone )(XT[^;/]*) Build'
        device: 'Motorola $1$2'
        brand: 'Motorola'
        model: '$2'
      - regex: '; *(Motoroi ?x|Droid X|DROIDX) Build'
        regex_flag: 'i'
        device: 'Motorola $1'
        brand: 'Motorola'
        model: 'DROID X'
      - regex: '; *(Droid[^;/]*|DROID[^;/]*|Milestone[^;/]*|Photon|Triumph|Devour|Titanium) Build'
        device: 'Motorola $1'
        brand: 'Motorola'
        model: '$1'
      - regex: '; *(A555|A85[34][^;/]*|A95[356]|ME[58]\d{2}\+?|ME600|ME632|ME722|MB\d{3}\+?|MT680|MT710|MT870|MT887|MT917|WX435|WX453|WX44[25]|XT\d{3,4}[A-Z\+]*|CL[iI]Q|CL[iI]Q XT|Nexus 6) Build'
        device: 'Motorola $1'
        brand: 'Motorola'
        model: '$1'
      - regex: '; *(Motorola MOT-|Motorola[ _\-]|MOT\-?)([^;/]+) Build'
        device: 'Motorola $1$2'
        brand: 'Motorola'
        model: '$2'
      - regex: '; *(Moto[_ ]?|MOT\-)([^;/]+) Build'
        device: 'Motorola $1$2'
        brand: 'Motorola'
        model: '$2'

      #########
      # MpMan
      # @ref: http://www.mpmaneurope.com
      #########
      - regex: '; *((?:MP[DQ]C|MPG\d{1,4}|MP\d{3,4}|MID(?:(?:10[234]|114|43|7[247]|8[24]|7)C|8[01]1))[^;/]*) Build'
        device: '$1'
        brand: 'Mpman'
        model: '$1'

      #########
      # MSI
      # @ref: http://www.msi.com/product/windpad/
      #########
      - regex: '; *(?:MSI[ _])?(Primo\d+|Enjoy[ _\-][^;/]+) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'Msi'
        model: '$1'

      #########
      # Multilaser
      # http://www.multilaser.com.br/listagem_produtos.php?cat=5
      #########
      - regex: '; *Multilaser[ _]([^;/]+) Build'
        device: '$1'
        brand: 'Multilaser'
        model: '$1'

      #########
      # MyPhone
      # @ref: http://myphone.com.ph/
      #########
      - regex: '; *(My)[_]?(Pad)[ _]([^;/]+) Build'
        device: '$1$2 $3'
        brand: 'MyPhone'
        model: '$1$2 $3'
      - regex: '; *My\|?Phone[ _]([^;/]+)(?: *Build|;)'
        regex_flag: 'i'
        device: 'MyPhone $1'
        brand: 'MyPhone'
        model: '$1'
      - regex: '; *(?:(A\d+|A818i)[ _](Duo)|(A919i?)) Build'
        regex_flag: 'i'
        device: '$1 $2$3'
        brand: 'MyPhone'
        model: '$1 $2$3'

      #########
      # Mytab
      # @ref: http://www.mytab.eu/en/category/mytab-products/
      #########
      - regex: '; *(my(?:Tab|TAB)[^;/]*) Build'
        device: '$1'
        brand: 'Mytab'
        model: '$1'

      #########
      # Mysaga
      # @ref: http://www.sagaphones.com
      #########
      - regex: '; *(?:MY ?SAGA|MySAGA)[ -]([^;/]+) Build'
        device: 'Mysaga $1'
        brand: 'Mysaga'
        model: '$1'

      #########
      # Nabi
      # @ref: https://www.nabitablet.com
      #########
      - regex: '; *(NABI2?-)([^;/]+) Build/'
        device: '$1$2'
        brand: 'Nabi'
        model: '$2'

      #########
      # Nec Medias
      # @ref: http://www.n-keitai.com/
      #########
      - regex: '; *(N-\d+[CDE]|101N) Build/'
        device: '$1'
        brand: 'Nec'
        model: '$1'
      - regex: '; ?(NEC-)(.*) Build/'
        device: '$1$2'
        brand: 'Nec'
        model: '$2'
      - regex: '; *(LT-NA7) Build/'
        device: '$1'
        brand: 'Nec'
        model: 'Lifetouch Note'

      #########
      # Nextbook
      # @ref: http://nextbookusa.com
      #########
      - regex: '; *(NXM\d+[A-z0-9_]*|Next\d[A-z0-9_ \-]*|NEXT\d[A-z0-9_ \-]*|Nextbook [A-z0-9_ ]*|DATAM803HC|M805)(?: Build|[\);])'
        device: '$1'
        brand: 'Nextbook'
        model: '$1'

      #########
      # Neken
      # @ref: http://www.neken.cn/
      #########
      - regex: '; *neken ([^;/]*) Build/'
        device: 'Neken $1'
        brand: 'Neken'

      #########
      # Newman
      # @ref: ?
      #########
      - regex: '; *Newman ?([^;/]*) Build/'
        regex_flag: 'i'
        device: 'Newman $1'
        brand: 'Newman'
        model: '$1'

      #########
      # NGM Mobile
      # @ref: http://www.ngm-mobile.com/
      #########
      - regex: '; *(Dynamic_(?:Fun|Maxi|Milo)|Enspert_Miracle|Forward_(?:Art|Escape|Prime|Run|Young)|Stylo) Build/'
        device: 'NGM $1'
        brand: 'NGM'
        model: '$1'
      - regex: '; *NGM[ _](Dynamic Star|Miracle|P0laris|Wilco) Build/'
        device: 'NGM $1'
        brand: 'NGM'
        model: '$1'

      #########
      # Nikon
      # @ref: http://imaging.nikon.com/lineup/coolpix/s/s800c/
      #########
      - regex: '; *(COOLPIX S800c) Build/'
        device: '$1'
        brand: 'Nikon'
        type: 'camera'

      #########
      # Nokia
      # @ref: http://www.nokia.com
      #########
      - regex: '; *(Nokia)([ _\-]*)([^;/]*) Build'
        regex_flag: 'i'
        device: '$1$2$3'
        brand: 'Nokia'
        model: '$3'

      #########
      # Nook
      # @ref:
      # TODO nook browser/1.0
      #########
      - regex: '; *(Nook ?|Barnes & Noble Nook |BN )([^;/]+) Build'
        device: '$1$2'
        brand: 'Nook'
        model: '$2'
      - regex: '; *(NOOK )?(BN[TR]V\d+A?|LogicPD Zoom2) Build'
        device: '$1$2'
        brand: 'Nook'
        model: '$2'
      - regex: '; Build/(Nook)'
        device: '$1'
        brand: 'Nook'
        model: 'Tablet'

      #########
      # NYX
      # @ref: http://www.nyxmobilemexico.com/
      #########
      - regex: '; *(NYX)_([^;/_]+)(?:_([^;/_]+))? Build'
        device: '$1 $2 $3'
        brand: 'NYX'
        model: '$2 $3'

      #########
      # Olivetti
      # @ref: http://www.olivetti.de/EN/Page/t02/view_html?idp=348
      #########
      - regex: '; *(OP110|OliPad[^;/]+) Build'
        device: 'Olivetti $1'
        brand: 'Olivetti'
        model: '$1'

      #########
      # Omega
      # @ref: http://omega-technology.eu/en/produkty/346/tablets
      # @note: MID tablets might get matched by CobyKyros first
      # @models: (T107|MID(?:700[2-5]|7031|7108|7132|750[02]|8001|8500|9001|971[12])
      #########
      - regex: '; *OMEGA[ _\-](MID[^;/]+) Build'
        device: 'Omega $1'
        brand: 'Omega'
        model: '$1'
      - regex: '^(MID7500|MID\d+) Mozilla/5\.0 \(iPad;'
        device: 'Omega $1'
        brand: 'Omega'
        model: '$1'


      #########
      # Oneplus
      # @ref: https://oneplus.net/de
      #########
      - regex: '; *(?:(?:One )?A0001|ONEPLUS One) Build'
        device: 'Oneplus One'
        brand: 'Oneplus'
        model: 'One'

      #########
      # OpenPeak
      # @ref: https://support.google.com/googleplay/answer/1727131?hl=en
      #########
      - regex: '; *((?:CIUS|cius)[^;/]*) Build'
        device: 'Openpeak $1'
        brand: 'Openpeak'
        model: '$1'

      #########
      # Oppo
      # @ref: http://en.oppo.com/products/
      #########
      - regex: '; *(Find ?(?:5|7a)|R8[012]\d{1,2}|T703\d{0,1}|U70\d{1,2}T?|X90\d{1,2}) Build'
        device: 'Oppo $1'
        brand: 'Oppo'
        model: '$1'
      - regex: '; *OPPO ?([^;/]+) Build/'
        device: 'Oppo $1'
        brand: 'Oppo'
        model: '$1'

      #########
      # Odys
      # @ref: http://odys.de
      #########
      - regex: '; *(?:Odys\-|ODYS\-|ODYS )([^;/]+) Build'
        device: 'Odys $1'
        brand: 'Odys'
        model: '$1'
      - regex: '; *(SELECT) ?(7) Build'
        device: 'Odys $1 $2'
        brand: 'Odys'
        model: '$1 $2'
      - regex: '; *(PEDI)_(PLUS)_(W) Build'
        device: 'Odys $1 $2 $3'
        brand: 'Odys'
        model: '$1 $2 $3'
      # Weltbild - Tablet PC 4 = Cat Phoenix = Odys Tablet PC 4?
      - regex: '; *(AEON|ARIA|AVIATOR|BRAVIO|CONNECT7PRO|CONNECT8PLUS|EOS10|FUSION|FUSION2IN1|Genio|GATE|IEOS[^;/]*|IRON|INTELLITAB7|JUNIORTAB|Loox|LOOX|LOOX Plus|MIRON|Motion|NERON|NOON|NOON970|NOON_PRO|NEXT|OPOS|PEDI[^;/]*|PRIME[^;/]*|PRO_Q8|SKYPLUS3G|STUDYTAB|TABLO|Tablet-PC-4|UNO_X8|UNO_X10|VISIO|XELIO[^;/]*|Xelio ?\d+ ?[Pp]ro|XelioPT2Pro|XENO10|XPRESS PRO) Build'
        device: 'Odys $1'
        brand: 'Odys'
        model: '$1'

      #########
      # Orion
      # @ref: http://www.orion.ua/en/products/computer-products/tablet-pcs.html
      #########
      - regex: '; *(TP-\d+) Build/'
        device: 'Orion $1'
        brand: 'Orion'
        model: '$1'

      #########
      # PackardBell
      # @ref: http://www.packardbell.com/pb/en/AE/content/productgroup/tablets
      #########
      - regex: '; *(G100W?) Build/'
        device: 'PackardBell $1'
        brand: 'PackardBell'
        model: '$1'

      #########
      # Panasonic
      # @ref: http://panasonic.jp/mobile/
      # @models: T11, T21, T31, P11, P51, Eluga Power, Eluga DL1
      # @models: (tab) Toughpad FZ-A1, Toughpad JT-B1
      #########
      - regex: '; *(Panasonic)[_ ]([^;/]+) Build'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      # Toughpad
      - regex: '; *(FZ-A1B|JT-B1) Build'
        device: 'Panasonic $1'
        brand: 'Panasonic'
        model: '$1'
      # Eluga Power
      - regex: '; *(dL1|DL1) Build'
        device: 'Panasonic $1'
        brand: 'Panasonic'
        model: '$1'

      #########
      # Pantech
      # @href: http://www.pantech.co.kr/en/prod/prodList.do?gbrand=PANTECH
      # @href: http://www.pantech.co.kr/en/prod/prodList.do?gbrand=VEGA
      # @models: ADR8995, ADR910L, ADR930VW, C790, CDM8992, CDM8999, IS06, IS11PT, P2000, P2020, P2030, P4100, P5000, P6010, P6020, P6030, P7000, P7040, P8000, P8010, P9020, P9050, P9060, P9070, P9090, PT001, PT002, PT003, TXT8040, TXT8045, VEGA PTL21
      #########
      - regex: '; *(SKY[ _])?(IM\-[AT]\d{3}[^;/]+).* Build/'
        device: 'Pantech $1$2'
        brand: 'Pantech'
        model: '$1$2'
      - regex: '; *((?:ADR8995|ADR910L|ADR930L|ADR930VW|PTL21|P8000)(?: 4G)?) Build/'
        device: '$1'
        brand: 'Pantech'
        model: '$1'
      - regex: '; *Pantech([^;/]+).* Build/'
        device: 'Pantech $1'
        brand: 'Pantech'
        model: '$1'

      #########
      # Papayre
      # @ref: http://grammata.es/
      #########
      - regex: '; *(papyre)[ _\-]([^;/]+) Build/'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Papyre'
        model: '$2'

      #########
      # Pearl
      # @ref: http://www.pearl.de/c-1540.shtml
      #########
      - regex: '; *(?:Touchlet )?(X10\.[^;/]+) Build/'
        device: 'Pearl $1'
        brand: 'Pearl'
        model: '$1'

      #########
      # Phicomm
      # @ref: http://www.phicomm.com.cn/
      # @ref: http://www.phicommasia.com/
      #########
      - regex: '; PHICOMM (i800) Build/'
        device: 'Phicomm $1'
        brand: 'Phicomm'
        model: '$1'
      - regex: '; PHICOMM ([^;/]+) Build/'
        device: 'Phicomm $1'
        brand: 'Phicomm'
        model: '$1'
      - regex: '; *(FWS\d{3}[^;/]+|i600|i813w) Build/'
        device: 'Phicomm $1'
        brand: 'Phicomm'
        model: '$1'

      #########
      # Philips
      # @ref: http://www.support.philips.com/support/catalog/products.jsp?_dyncharset=UTF-8&country=&categoryid=MOBILE_PHONES_SMART_SU_CN_CARE&userLanguage=en&navCount=2&groupId=PC_PRODUCTS_AND_PHONES_GR_CN_CARE&catalogType=&navAction=push&userCountry=cn&title=Smartphones&cateId=MOBILE_PHONES_CA_CN_CARE
      # @TODO: Philips Tablets User-Agents missing!
      # @ref: http://www.support.philips.com/support/catalog/products.jsp?_dyncharset=UTF-8&country=&categoryid=ENTERTAINMENT_TABLETS_SU_CN_CARE&userLanguage=en&navCount=0&groupId=&catalogType=&navAction=push&userCountry=cn&title=Entertainment+Tablets&cateId=TABLETS_CA_CN_CARE
      #########
      # @note: this a best guess according to available philips models. Need more User-Agents
      - regex: '; *(D633|D822|D833|T539|T939|V726|W335|W336|W337|W3568|W536|W5510|W626|W632|W6350|W6360|W6500|W732|W736|W737|W7376|W820|W832|W8355|W8500|W8510|W930) Build'
        device: '$1'
        brand: 'Philips'
        model: '$1'
      - regex: '; *(?:Philips|PHILIPS)[ _]([^;/]+) Build'
        device: 'Philips $1'
        brand: 'Philips'
        model: '$1'

      #########
      # Pipo
      # @ref: http://www.pipo.cn/En/
      #########
      - regex: 'Android 4\..*; *(M[12356789]|U[12368]|S[123])\ ?(pro)? Build'
        device: 'Pipo $1$2'
        brand: 'Pipo'
        model: '$1$2'

      #########
      # Ployer
      # @ref: http://en.ployer.cn/
      #########
      - regex: '; *(MOMO[^;/]+) Build'
        device: '$1'
        brand: 'Ployer'
        model: '$1'

      #########
      # Polaroid/ Acho
      # @ref: http://polaroidstore.com/store/start.asp?category_id=382&category_id2=0&order=title&filter1=&filter2=&filter3=&view=all
      #########
      - regex: '; *(?:Polaroid[ _])?((?:MIDC\d{3,}|PMID\d{2,}|PTAB\d{3,})[^;/]*)(\/[^;/]*)? Build/'
        device: '$1'
        brand: 'Polaroid'
        model: '$1'
      - regex: '; *(?:Polaroid )(Tablet) Build/'
        device: '$1'
        brand: 'Polaroid'
        model: '$1'

      #########
      # Pomp
      # @ref: http://pompmobileshop.com/
      #########
      - regex: '; *(POMP)[ _\-](.+?) *(?:Build|[;/\)])'
        device: '$1 $2'
        brand: 'Pomp'
        model: '$2'

      #########
      # Positivo
      # @ref: http://www.positivoinformatica.com.br/www/pessoal/tablet-ypy/
      #########
      - regex: '; *(TB07STA|TB10STA|TB07FTA|TB10FTA) Build/'
        device: '$1'
        brand: 'Positivo'
        model: '$1'
      - regex: '; *(?:Positivo )?((?:YPY|Ypy)[^;/]+) Build/'
        device: '$1'
        brand: 'Positivo'
        model: '$1'

      #########
      # POV
      # @ref: http://www.pointofview-online.com/default2.php
      # @TODO: Smartphone Models MOB-3515, MOB-5045-B missing
      #########
      - regex: '; *(MOB-[^;/]+) Build/'
        device: '$1'
        brand: 'POV'
        model: '$1'
      - regex: '; *POV[ _\-]([^;/]+) Build/'
        device: 'POV $1'
        brand: 'POV'
        model: '$1'
      - regex: '; *((?:TAB-PLAYTAB|TAB-PROTAB|PROTAB|PlayTabPro|Mobii[ _\-]|TAB-P)[^;/]*) Build/'
        device: 'POV $1'
        brand: 'POV'
        model: '$1'

      #########
      # Prestigio
      # @ref: http://www.prestigio.com/catalogue/MultiPhones
      # @ref: http://www.prestigio.com/catalogue/MultiPads
      #########
      - regex: '; *(?:Prestigio )?((?:PAP|PSP|PMP|PMT)\d[^;/]+) Build/'
        device: 'Prestigio $1'
        brand: 'Prestigio'
        model: '$1'

      #########
      # Proscan
      # @ref: http://www.proscanvideo.com/products-search.asp?itemClass=TABLET&itemnmbr=
      #########
      - regex: '; *(PLT[0-9]{4}.*) Build/'
        device: '$1'
        brand: 'Proscan'
        model: '$1'

      #########
      # QMobile
      # @ref: http://www.qmobile.com.pk/
      #########
      - regex: '; *(A2|A5|A8i?|A900i?|A950)_?(Classic)? Build'
        device: '$1 $2'
        brand: 'Qmobile'
        model: '$1 $2'
      - regex: '; *(A\d+) Build.*QMobile'
        device: '$1'
        brand: 'Qmobile'
        model: '$1 $2'
      - regex: '; *(Q[Mm]obile)_([^_]+)_([^_;/\)]+)(?: Build|\)|;)'
        device: 'Qmobile $2 $3'
        brand: 'Qmobile'
        model: '$2 $3'
      - regex: '; *(Q[Mm]obile)[_ ]([^;/\)]+)(?: Build|\)|;)'
        device: 'Qmobile $2'
        brand: 'Qmobile'
        model: '$2'

      #########
      # Qmobilevn
      # @ref: http://qmobile.vn/san-pham.html
      #########
      - regex: '; *(Q\-Smart)[ _]([^;/]+) Build/'
        device: '$1 $2'
        brand: 'Qmobilevn'
        model: '$2'
      - regex: '; *(Q\-?[Mm]obile)[ _\-](S[^;/]+) Build/'
        device: '$1 $2'
        brand: 'Qmobilevn'
        model: '$2'

      #########
      # Quanta
      # @ref: ?
      #########
      - regex: '; *(TA1013) Build'
        device: '$1'
        brand: 'Quanta'
        model: '$1'

      #########
      # Ramos
      # @ref: http://www.ramos-tablet.com/
      #########
      - regex: '; *Ramos ?([^;/]+) Build/'
        device: 'Ramos $1'
        brand: 'Ramos'
        model: '$1'
        type: 'tablet'

      #########
      # Rockchip
      # @ref: http://www.rock-chips.com/a/cn/product/index.html
      # @note: manufacturer sells chipsets - I assume that these UAs are dev-boards
      #########
      - regex: '; *(RK\d+),? Build/'
        device: '$1'
        brand: 'Rockchip'
        model: '$1'
      - regex: ' Build/(RK\d+)'
        device: '$1'
        brand: 'Rockchip'
        model: '$1'

      #########
      # Runbo
      # @ref: http://www.runbodirect.co.uk/
      #########
      - regex: '; *Runbo([^;/]+) Build/'
        device: 'Runbo $1'
        brand: 'Runbo'
        model: '$1'

      #########
      # Sharp
      # @ref: http://www.sharp-phone.com/en/index.html
      # @ref: http://www.android.com/devices/?country=all&m=sharp
      #########
      - regex: '; *(SH\-?\d\d[^;/]+|SBM\d[^;/]+|SH[LTV]\d{2}|[34]0\dSH) Build'
        device: 'Sharp $1'
        brand: 'Sharp'
        model: '$1'
      - regex: '; *(SHARP[ -])([^;/]+) Build'
        device: '$1$2'
        brand: 'Sharp'
        model: '$2'

      #########
      # Simvalley
      # @ref: http://www.simvalley-mobile.de/
      #########
      - regex: '; *(SPX[_\-]\d[^;/]*) Build/'
        device: '$1'
        brand: 'Simvalley'
        model: '$1'
      - regex: '; *(SX7\-PEARL\.GmbH) Build/'
        device: '$1'
        brand: 'Simvalley'
        model: '$1'
      - regex: '; *(SP[T]?\-\d{2}[^;/]*) Build/'
        device: '$1'
        brand: 'Simvalley'
        model: '$1'

      #########
      # SK Telesys
      # @ref: http://www.sk-w.com/phone/phone_list.jsp
      # @ref: http://www.android.com/devices/?country=all&m=sk-telesys
      #########
      - regex: '; *(SK\-.*) Build/'
        device: '$1'
        brand: 'SKtelesys'
        model: '$1'

      #########
      # Skytex
      # @ref: http://skytex.com/android
      #########
      - regex: '; *(?:SKYTEX|SX)-([^;/]+) Build'
        device: '$1'
        brand: 'Skytex'
        model: '$1'
      - regex: '; *(IMAGINE [^;/]+) Build'
        device: '$1'
        brand: 'Skytex'
        model: '$1'

      #########
      # SmartQ
      # @ref: http://en.smartdevices.com.cn/Products/
      # @models: Z8, X7, U7H, U7, T30, T20, Ten3, V5-II, T7-3G, SmartQ5, K7, S7, Q8, T19, Ten2, Ten, R10, T7, R7, V5, V7, SmartQ7
      #########
      - regex: '; *(SmartQ) ?([^;/]+) Build/'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Smartbitt
      # @ref: http://www.smartbitt.com/
      # @missing: SBT Useragents
      #########
      - regex: '; *(WF7C|WF10C|SBT[^;/]+) Build'
        device: '$1'
        brand: 'Smartbitt'
        model: '$1'

      #########
      # Softbank (Operator Branded Devices)
      # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
      #########
      - regex: '; *(SBM(?:003SH|005SH|006SH|007SH|102SH)) Build'
        device: '$1'
        brand: 'Sharp'
        model: '$1'
      - regex: '; *(003P|101P|101P11C|102P) Build'
        device: '$1'
        brand: 'Panasonic'
        model: '$1'
      - regex: '; *(00\dZ) Build/'
        device: '$1'
        brand: 'ZTE'
        model: '$1'
      - regex: '; HTC(X06HT) Build'
        device: '$1'
        brand: 'HTC'
        model: '$1'
      - regex: '; *(001HT|X06HT) Build'
        device: '$1'
        brand: 'HTC'
        model: '$1'
      - regex: '; *(201M) Build'
        device: '$1'
        brand: 'Motorola'
        model: 'XT902'
      - regex: '; *([123]0\dF) Build'
        device: '$1'
        brand: 'Fujitsu'
        model: '$1'

      #########
      # Trekstor
      # @ref: http://www.trekstor.co.uk/surftabs-en.html
      # @note: Must come before SonyEricsson
      #########
      - regex: '; *(ST\d{4}.*)Build/ST'
        device: 'Trekstor $1'
        brand: 'Trekstor'
        model: '$1'
      - regex: '; *(?:TrekStor )?(ST\d{4}.*|VT10416-\d|SurfTab ST\d{4}.*|SurfTab (?:breeze|xiron) [^;]*|breeze [^;]*|Xintroni[^;]+) Build/'
        device: 'Trekstor $1'
        brand: 'Trekstor'
        model: '$1'

      #########
      # Smartbook
      # @ref: http://www.smartbook.de/
      #########
      - regex: '; *Smartbook[^ ]? ([^;/]+) Build'
        regex_flag: 'i'
        device: 'Smartbook $1'
        brand: 'Smartbook'
        model: '$1'

      #########
      # SonyEricsson
      # @note: Must come before nokia since they also use symbian
      # @ref: http://www.android.com/devices/?country=all&m=sony-ericssons
      # @TODO: type!
      #########
      # android matchers
      - regex: '; *(Sony ?Ericsson ?)([^;/]+) Build'
        device: '$1$2'
        brand: 'SonyEricsson'
        model: '$2'
      - regex: '; *((?:SK|ST|LT|MK|MT|WT)\d{2}[a-z0-9]*(?:-o)?|E\d{2,3}[a-z]?|R800[ai]|U20i|X(?:10|15)(?:[a-z]?|mini|minipro)) Build'
        device: '$1'
        brand: 'SonyEricsson'
        model: '$1'
      # TODO X\d+ is wrong
      - regex: '; *(Xperia (?:A8|Arc|Acro|Active|Live with Walkman|Mini|Neo|Play|Pro|Ray|X\d+)[^;/]*) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'SonyEricsson'
        model: '$1'

      #########
      # Sony
      # @ref: http://www.sonymobile.co.jp/index.html
      # @ref: http://www.sonymobile.com/global-en/products/phones/
      # @ref: http://www.sony.jp/tablet/
      #########
      - regex: '; Sony (Tablet[^;/]+) Build'
        device: 'Sony $1'
        brand: 'Sony'
        model: '$1'
      - regex: '; Sony ([^;/]+) Build'
        device: 'Sony $1'
        brand: 'Sony'
        model: '$1'
      - regex: '; *(Sony)([A-Za-z0-9\-]+) Build'
        device: '$1$2'
        brand: '$1'
        model: '$2'
      - regex: '; *(Xperia [^;/]+) Build'
        device: '$1'
        brand: 'Sony'
        model: '$1'
      - regex: '; *(C(?:1[5-9]|2[1-9]|53|55|6[0-9])[0-9]{2}|C200[1-9]|D[25]\d{3}|D6[567]\d{2}|E200[1-9]|E2[^0]\d{2}|E20[345]3|E5[356]\d{2}|E5823|E6[568]\d{2});? Build'
        device: '$1'
        brand: 'Sony'
        model: '$1'
      - regex: '; *(SGP\d{3}|SGPT\d{2}|S39h) Build'
        device: '$1'
        brand: 'Sony'
        model: '$1'
      - regex: '; *(NW-Z1000Series) Build'
        device: '$1'
        brand: 'Sony'
        model: '$1'

      #########
      # Spice
      # @ref: http://www.spicemobilephones.co.in/
      #########
      - regex: '; *((?:CSL_Spice|Spice|SPICE|CSL)[ _\-]?)?([Mm][Ii])([ _\-])?(\d{3}[^;/]*) Build/'
        device: '$1$2$3$4'
        brand: 'Spice'
        model: 'Mi$4'

      #########
      # Sprint (Operator Branded Devices)
      # @ref:
      #########
      - regex: 'Sprint (ATP.*) Build'
        brand: 'HTC'
        type: 'tablet'
        model: '$1'
      - regex: 'Sprint (APA.*) Build'
        brand: 'HTC'
        model: '$1'
        type: 'smartphone'
      - regex: '; *(Sprint )(.+?) *(?:Build|[;/])'
        device: '$1$2'
        brand: 'Sprint'
        model: '$2'

      #########
      # Switel
      # @ref: http://www.switelmobile.com
      #########
      - regex: '; *(DRAGON S5000D|JAZZ S47D|S40D MAGIC|S50D SKY|S57D SAMBA|S4500D ROCK) Build/'
        device: '$1'
        brand: 'Switel'
        model: '$1'

      #########
      # Symphony
      # @ref: http://symphony-mobile.com/
      #########
      - regex: '; *(Symphony)[ _](.+?)(?: Build|[;\)/])'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      - regex: '; *([^;/]+) Build/(Symphony)'
        device: '$2 $1'
        brand: '$2'
        model: '$1'

      #########
      # Tagi
      # @ref: ??
      #########
      - regex: '; *(TAGI[ ]?)(MID) ?([^;/]+) Build/'
        device: '$1$2$3'
        brand: 'Tagi'
        model: '$2$3'

      #########
      # Tecmobile
      # @ref: http://www.tecmobile.com/
      #########
      - regex: '; *(Oyster500|Opal 800) Build'
        device: 'Tecmobile $1'
        brand: 'Tecmobile'
        model: '$1'

      #########
      # Tecno
      # @ref: www.tecno-mobile.com/‎
      #########
      - regex: '; *(TECNO[ _])([^;/]+) Build/'
        device: '$1$2'
        brand: 'Tecno'
        model: '$2'

      #########
      # Telechips, Techvision evaluation boards
      # @ref:
      #########
      - regex: '; *Android for (Telechips|Techvision) ([^ ]+) '
        regex_flag: 'i'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Telstra
      # @ref: http://www.telstra.com.au/home-phone/thub-2/
      # @ref: https://support.google.com/googleplay/answer/1727131?hl=en
      #########
      - regex: '; *(T-Hub2) Build/'
        device: '$1'
        brand: 'Telstra'
        model: '$1'

      #########
      # Terra
      # @ref: http://www.wortmann.de/
      #########
      - regex: '; *(PAD) ?(100[12]) Build/'
        device: 'Terra $1$2'
        brand: 'Terra'
        model: '$1$2'

      #########
      # Texet
      # @ref: http://www.texet.ru/tablet/
      #########
      - regex: '; *(T[BM]-\d{3}[^;/]+) Build/'
        device: '$1'
        brand: 'Texet'
        model: '$1'

      #########
      # TiPhone
      # @ref: ??
      #########
      - regex: '; *(TiPhone)[ \-]([^;/]+) Build/'
        device: '$1 $2'
        brand: 'TiPhone'
        model: '$2'
        type: 'smartphone'

      #########
      # Thalia
      # @ref: http://www.thalia.de/shop/tolino-shine-ereader/show/
      #########
      - regex: '; *(tolino [^;/]+) Build'
        device: '$1'
        brand: 'Thalia'
        model: '$1'
      - regex: '; *Build/.* (TOLINO_BROWSER)'
        device: '$1'
        brand: 'Thalia'
        model: 'Tolino Shine'

      #########
      # Thl
      # @ref: http://en.thl.com.cn/Mobile
      # @ref: http://thlmobilestore.com
      #########
      - regex: '; *(?:CJ[ -])?(ThL|THL|thl)[ _\-]{1,2}([^;/]+) Build/'
        device: '$1 $2'
        brand: 'Thl'
        model: '$2'
      - regex: '; *(T100|T200C?|T5|W100|W200|W8s) Build/'
        device: '$1'
        brand: 'Thl'
        model: '$1'

      #########
      # T-Mobile (Operator Branded Devices)
      #########
      # @ref: https://en.wikipedia.org/wiki/HTC_Hero
      - regex: '; *(T-Mobile[ _]G2[ _]Touch) Build'
        device: '$1'
        brand: 'HTC'
        model: 'Hero'
      # @ref: https://en.wikipedia.org/wiki/HTC_Desire_Z
      - regex: '; *(T-Mobile[ _]G2) Build'
        device: '$1'
        brand: 'HTC'
        model: 'Desire Z'
      - regex: '; *(T-Mobile myTouch Q) Build'
        device: '$1'
        brand: 'Huawei'
        model: 'U8730'
      - regex: '; *(T-Mobile myTouch) Build'
        device: '$1'
        brand: 'Huawei'
        model: 'U8680'
      - regex: '; *(T-Mobile_Espresso) Build'
        device: '$1'
        brand: 'HTC'
        model: 'Espresso'
      - regex: '; *(T-Mobile G1) Build'
        device: '$1'
        brand: 'HTC'
        model: 'Dream'
      - regex: '\b(T-Mobile ?)?(myTouch)[ _]?([34]G)[ _]?([^\/]*) (?:Mozilla|Build)'
        device: '$1$2 $3 $4'
        brand: 'HTC'
        model: '$2 $3 $4'
      - regex: '\b(T-Mobile)_([^_]+)_(.*) Build'
        device: '$1 $2 $3'
        brand: 'Tmobile'
        model: '$2 $3'
      - regex: '\b(T-Mobile)[_ ]?(.*?)Build'
        device: '$1 $2'
        brand: 'Tmobile'
        model: '$2'

      #########
      # Tomtec
      # @ref: http://www.tom-tec.eu/pages/tablets.php
      #########
      - regex: ' (ATP[0-9]{4}) Build'
        device: '$1'
        brand: 'Tomtec'
        model: '$1'

      #########
      # Tooky
      # @ref: http://www.tookymobile.com/
      #########
      - regex: ' *(TOOKY)[ _\-]([^;/]+) ?(?:Build|;)'
        regex_flag: 'i'
        device: '$1 $2'
        brand: 'Tooky'
        model: '$2'

      #########
      # Toshiba
      # @ref: http://www.toshiba.co.jp/
      # @missing: LT170, Thrive 7, TOSHIBA STB10
      #########
      - regex: '\b(TOSHIBA_AC_AND_AZ|TOSHIBA_FOLIO_AND_A|FOLIO_AND_A)'
        device: '$1'
        brand: 'Toshiba'
        model: 'Folio 100'
      - regex: '; *([Ff]olio ?100) Build/'
        device: '$1'
        brand: 'Toshiba'
        model: 'Folio 100'
      - regex: '; *(AT[0-9]{2,3}(?:\-A|LE\-A|PE\-A|SE|a)?|AT7-[ABC]|AT1S0|Hikari-iFrame/WDPF-[^;/]+|THRiVE|Thrive) Build/'
        device: 'Toshiba $1'
        brand: 'Toshiba'
        model: '$1'

      #########
      # Touchmate
      # @ref: http://touchmatepc.com/new/
      #########
      - regex: '; *(TM-MID\d+[^;/]+|TOUCHMATE|MID-750) Build'
        device: '$1'
        brand: 'Touchmate'
        model: '$1'
      # @todo: needs verification user-agents missing
      - regex: '; *(TM-SM\d+[^;/]+) Build'
        device: '$1'
        brand: 'Touchmate'
        model: '$1'

      #########
      # Treq
      # @ref: http://www.treq.co.id/product
      #########
      - regex: '; *(A10 [Bb]asic2?) Build/'
        device: '$1'
        brand: 'Treq'
        model: '$1'
      - regex: '; *(TREQ[ _\-])([^;/]+) Build'
        regex_flag: 'i'
        device: '$1$2'
        brand: 'Treq'
        model: '$2'

      #########
      # TWM
      # @ref: http://www.taiwanmobile.com
      #########
      - regex: '; *(Amazing [^;/]+) Build'
        device: '$1'
        brand: 'TWM'
        model: '$1'

      #########
      # Umeox
      # @ref: http://umeox.com/
      # @models: A936|A603|X-5|X-3
      #########
      # @todo: guessed markers
      - regex: '; *(X-?5|X-?3) Build/'
        device: '$1'
        brand: 'Umeox'
        model: '$1'
      # @todo: guessed markers
      - regex: '; *(A502\+?|A936|A603|X1|X2) Build/'
        device: '$1'
        brand: 'Umeox'
        model: '$1'

      #########
      # Umi
      # @ref: http://www.91umi.com/
      #########
      - regex: '; (UMI)[ _](.+?) Build/'
        device: '$1 $2'
        brand: 'Umi'
        model: '$2'

      #########
      # Versus
      # @ref: http://versusuk.com/support.html
      #########
      - regex: '(?:CnM)[ \-](.+?) Build/'
        regex_flag: 'i'
        device: 'CnM $1'
        brand: 'CnM'
        model: '$1'
        type: 'tablet'
      - regex: '(?:VS|Versus)[ \-](.+?) Build/'
        regex_flag: 'i'
        device: 'Versus $1'
        brand: 'Versus'
        model: '$1'
        type: 'tablet'

      #########
      # Vertu
      # @ref: http://www.vertu.com/
      #########
      - regex: '(VERTU) ([^;/]+) Build/'
        device: '$1 $2'
        brand: 'Vertu'
        model: '$2'

      #########
      # Videocon
      # @ref: http://www.videoconmobiles.com
      #########
      - regex: '; *(Videocon)[ _\-]([^;/]+) *(?:Build|;)'
        device: '$1 $2'
        brand: 'Videocon'
        model: '$2'
      - regex: ' (VT\d{2}[A-Za-z]*|A55q?HD) Build'
        device: '$1'
        brand: 'Videocon'
        model: '$1'

      #########
      # Viewsonic
      # @ref: http://viewsonic.com
      #########
      - regex: '; *((?:ViewPad|ViewPhone|VSD)[^;/]+) Build/'
        device: '$1'
        brand: 'Viewsonic'
        model: '$1'
      - regex: '; *(ViewSonic-)([^;/]+) Build/'
        device: '$1$2'
        brand: 'Viewsonic'
        model: '$2'
      - regex: '; *(GTablet.*) Build/'
        device: '$1'
        brand: 'Viewsonic'
        model: '$1'

      #########
      # vivo (BBK COMMUNICATION TECHNOLOGY CO.LTD)
      # @ref: http://www.vivo.com.cn/
      #########
      - regex: '; *([Vv]ivo)[ _]([^;/]+) Build'
        device: '$1 $2'
        brand: 'vivo'
        model: '$2'

      #########
      # Vodafone (Operator Branded Devices)
      # @ref: ??
      #########
      - regex: '(Vodafone) (.*) Build/'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

      #########
      # Vonino
      # @ref: http://www.vonino.eu/
      # TODO Vonino
      #########
      - regex: '; ((?:JAX|Xylo|Oxxo|Ego|Gyga)[ _](?:QS|S|Mini)).* Build'
        type: 'smartphone'
        device: '$1'
        brand: 'Vonino'
        model: '$1'
      - regex: '; (Argus[ _](QS|S)|Epic[ _]E7|Emerald[ _]78E|Diamond[ _]79HD|JetStar(?:[ _][^;/]+)?|Luna[ _]70C|Magnet_M9|(?:Onyx|Orin|Otis)[ _](?:QS|XS|S|Z|HD)|Primus (?:94HD.*|QS)|Sirius_(?:QS|Evo_QS)|SpeedStar S Pro|Spirit (QS|S)|Vario.*) Build'
        type: 'tablet'
        device: '$1'
        brand: 'Vonino'
        model: '$1'

      #########
      # Walton
      # @ref: http://www.waltonbd.com/
      #########
      - regex: '; *(?:Walton[ _\-])?(Primo[ _\-][^;/]+) Build'
        regex_flag: 'i'
        device: 'Walton $1'
        brand: 'Walton'
        model: '$1'

      #########
      # Wiko
      # @ref: http://fr.wikomobile.com/collection.php?s=Smartphones
      #########
      - regex: '; *(?:WIKO[ \-])?(CINK\+?|CINK [^;/]+|BARRY|BIRDY|BLOOM|DARKFULL|DARKMOON|DARKNIGHT|DARKSIDE|FIZZ|GETAWAY|GOA|HIGHWAY(?: PURE| SIGNS| STAR)?|IGGY|JIMMY|KITE|LENNY(?:2)?|OZZY|RAINBOW(?: JAM| LITE| UP)?|RIDGE(?: FAB)?|SLIDE|STAIRWAY|SUBLIM|SUNSET(?:2)?|WAX)( 4G)? Build/'
        regex_flag: 'i'
        device: 'Wiko $1$2'
        brand: 'Wiko'
        model: '$1$2'

      #########
      # WellcoM
      # @ref: ??
      #########
      - regex: '; *WellcoM-([^;/]+) Build'
        device: 'Wellcom $1'
        brand: 'Wellcom'
        model: '$1'

      ##########
      # WeTab
      # @ref: http://wetab.mobi/
      ##########
      - regex: '; ([Ww]e[Tt]ab[^;/]*?) *Build'
        device: '$1'
        brand: 'WeTab'
        model: '$1'

      #########
      # Wolfgang
      # @ref: http://wolfgangmobile.com/
      #########
      - regex: '; *(AT-AS[^;/]+) Build'
        device: 'Wolfgang $1'
        brand: 'Wolfgang'
        model: '$1'

      #########
      # Woxter
      # @ref: http://www.woxter.es/es-es/categories/index
      #########
      - regex: '; *(?:Woxter|Wxt) ([^;/]+) Build'
        device: 'Woxter $1'
        brand: 'Woxter'
        model: '$1'

      #########
      # Yarvik Zania
      # @ref: http://yarvik.com
      #########
      - regex: '; *(?:Xenta |Luna )?(TAB[234][0-9]{2}|TAB0[78]-\d{3}|TAB0?9-\d{3}|TAB1[03]-\d{3}|SMP\d{2}-\d{3}) Build/'
        device: 'Yarvik $1'
        brand: 'Yarvik'
        model: '$1'

      #########
      # Yifang
      # @note: Needs to be at the very last as manufacturer builds for other brands.
      # @ref: http://www.yifangdigital.com/
      # @models: M1010, M1011, M1007, M1008, M1005, M899, M899LP, M909, M8000,
      #   M8001, M8002, M8003, M849, M815, M816, M819, M805, M878, M780LPW,
      #   M778, M7000, M7000AD, M7000NBD, M7001, M7002, M7002KBD, M777, M767,
      #   M789, M799, M769, M757, M755, M753, M752, M739, M729, M723, M712, M727
      #########
      - regex: '; *([A-Z]{2,4})(M\d{3,}[A-Z]{2})([^;\)\/]*)(?: Build|[;\)])'
        device: 'Yifang $1$2$3'
        brand: 'Yifang'
        model: '$2'

      #########
      # XiaoMi
      # @ref: http://www.xiaomi.com/event/buyphone
      # @ref: http://www.mi.com/en
      #########
      - regex: '; *((?:MI|MI2|Mi|HM|MI-ONE|MiPad|Redmi)[ _][^;/]+) (?:Build|MIUI)/'
        device: 'XiaoMi $1'
        brand: 'XiaoMi'
        model: '$1'

      #########
      # Xolo
      # @ref: http://www.xolo.in/
      #########
      - regex: '; *XOLO[ _]([^;/]*tab.*) Build'
        regex_flag: 'i'
        device: 'Xolo $1'
        brand: 'Xolo'
        model: '$1'
      - regex: '; *XOLO[ _]([^;/]+) Build'
        regex_flag: 'i'
        device: 'Xolo $1'
        brand: 'Xolo'
        model: '$1'
      - regex: '; *(q\d0{2,3}[a-z]?|8x-1000|A(?:500|550|1000)s(?:[ _]Lite|[ _]IPS)?|A500 Club|A500L|A600) Build'
        regex_flag: 'i'
        device: 'Xolo $1'
        brand: 'Xolo'
        model: '$1'

      #########
      # Xoro
      # @ref: http://www.xoro.de/produkte/
      #########
      - regex: '; *(PAD ?[79]\d+[^;/]*|TelePAD\d+[^;/]) Build'
        device: 'Xoro $1'
        brand: 'Xoro'
        model: '$1'
      - regex: '; *(?:XORO|Xoro) (PAD ?\d+[^;/]*|KIDS\d+|TelePAD\d+[^;/]) Build'
        device: 'Xoro $1'
        brand: 'Xoro'
        model: '$1'

      #########
      # Xtouch
      # @ref: http://xtouch.pk/
      #########
      - regex: '; *(?:Xtouch[ _]([^;/]+)|(X401|X403|X405|X406|X506[s]?|X507[QSsT]?|X508|X509|X601)) Build'
        device: 'Xtouch $1$2'
        brand: 'Xtouch'
        model: '$1$2'

      #########
      # Yezz
      # @ref:
      #########
      - regex: '\b(Andy|yezz(?:[ -]andy)?)[ _-]([^;/]+) Build'
        regex_flag: 'i'
        device: 'Yezz Andy $2'
        brand: 'Yezz'
        model: 'Andy $2'

      #########
      # Zopo
      # @ref: http://www.zopomobiles.com/products.html
      #########
      - regex: '; *(?:(?:ZOPO|Zopo)[ _]([^;/]+)|(ZP ?(?:\d{2}[^;/]+|C2))|(C[2379])) Build'
        device: '$1$2$3'
        brand: 'Zopo'
        model: '$1$2$3'

      #########
      # ZiiLabs
      # @ref: http://www.ziilabs.com/products/platforms/androidreferencetablets.php
      #########
      - regex: '; *(ZiiLABS) (Zii[^;/]*) Build'
        device: '$1 $2'
        brand: 'ZiiLabs'
        model: '$2'
      - regex: '; *(Zii)_([^;/]*) Build'
        device: '$1 $2'
        brand: 'ZiiLabs'
        model: '$2'

      #########
      # ZTE
      # @ref: http://www.ztedevices.com/
      #########
      - regex: '; *(ARIZONA|(?:ATLAS|Atlas) W|D930|Grand (?:[SX][^;]*|Era|Memo[^;]*)|JOE|(?:Kis|KIS)\b[^;]*|Libra|Light [^;]*|N8[056][01]|N850L|N8000|N9[15]\d{2}|N9810|NX501|Optik|(?:Vip )Racer[^;]*|RacerII|RACERII|San Francisco[^;]*|V9[AC]|V55|V881|Z[679][0-9]{2}[A-z]?|ZTE_BLADE_III) Build'
        device: '$1'
        brand: 'ZTE'
        model: '$1'
      - regex: '; *([A-Z]\d+)_USA_[^;]* Build'
        device: '$1'
        brand: 'ZTE'
        model: '$1'
      - regex: '; *(SmartTab\d+)[^;]* Build'
        device: '$1'
        brand: 'ZTE'
        model: '$1'
      - regex: '; *(?:Blade|BLADE|ZTE-BLADE)([^;/]*) Build'
        device: 'ZTE Blade$1'
        brand: 'ZTE'
        model: 'Blade$1'
      - regex: '; *(?:Skate|SKATE|ZTE-SKATE)([^;/]*) Build'
        device: 'ZTE Skate$1'
        brand: 'ZTE'
        model: 'Skate$1'
      - regex: '; *(Orange |Optimus )(Monte Carlo|San Francisco) Build'
        device: '$1$2'
        brand: 'ZTE'
        model: '$1$2'
      - regex: '; *(?:ZXY-ZTE_|ZTE\-U |ZTE[\- ]|ZTE-C[_ ])([^;/]+) Build'
        device: 'ZTE $1'
        brand: 'ZTE'
        model: '$1'
      # operator specific
      - regex: '; (BASE) (lutea|Lutea 2|Tab[^;]*) Build'
        device: '$1 $2'
        brand: 'ZTE'
        model: '$1 $2'
      - regex: '; (Avea inTouch \d[^;/]*|soft stone|tmn smart a7|Movistar[ _]Link|KPN Smart 300|Orange Reyo|meo smart a12|MEO Smart A75|DIGICEL DL800|tmn smart a18|Turkcell Maxi Plus 5|TURKCELL T50|RACER III mini) Build'
        regex_flag: 'i'
        device: '$1'
        brand: 'ZTE'
        model: '$1'
      - regex: '; *(vp9plus)\)'
        device: '$1'
        brand: 'ZTE'
        model: '$1'

      ##########
      # Zync
      # @ref: http://www.zync.in/index.php/our-products/tablet-phablets
      ##########
      - regex: '; ?(Cloud[ _]Z5|z1000|Z99 2G|z99|z930|z999|z990|z909|Z919|z900) Build/'
        device: '$1'
        brand: 'Zync'
        model: '$1'

      ##########
      # Kindle
      # @note: Needs to be after Sony Playstation Vita as this UA contains Silk/3.2
      # @ref: https://developer.amazon.com/appsandservices/solutions/devices/kindle-fire/specifications/01-device-and-feature-specifications
      # @ref: http://amazonsilk.wordpress.com/useful-bits/silk-user-agent/
      ##########
      - regex: '; ?(Kindle Fire) Build\b'
        device: 'Kindle Fire'
        brand: 'Amazon'
        model: 'Kindle Fire'
      - regex: '; ?(KFOT|KFOTE|Amazon Kindle Fire2) Build\b'
        device: 'Kindle Fire 2'
        brand: 'Amazon'
        model: 'Kindle Fire 2'
      - regex: '; ?(KFTT|Kindle Fire HD 7) Build\b'
        device: 'Kindle Fire HD'
        brand: 'Amazon'
        model: 'Kindle Fire HD 7"'
      - regex: '; ?(KFSAWA) Build\b'
        brand: 'Amazon'
        model: 'Fire HDX 8.9 (4th Gen) Wan'
        device: 'Fire HDX 8.9 (4th Gen) Wan'
      - regex: '; ?(KFSAWI) Build\b'
        brand: 'Amazon'
        model: 'Fire HDX 8.9 (4th Gen)'
        device: 'Fire HDX 8.9 (4th Gen)'
      - regex: '; ?(KFASWI) Build\b'
        brand: 'Amazon'
        model: 'Fire HD 7 (4th Gen)'
        device: 'Fire HD 7 (4th Gen)'
      - regex: '; ?(KFARWI) Build\b'
        brand: 'Amazon'
        model: 'Fire HD 6 (4th Gen)'
        device: 'Fire HD 6 (4th Gen)'
      - regex: '; ?(KFTHWA) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 7" (3rd Gen) Wan'
        device: 'Kindle Fire HDX 7" (3rd Gen) Wan'
      - regex: '; ?(KFTHWI) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 7" (3rd Gen)'
        device: 'Kindle Fire HDX 7" (3rd Gen)'
      - regex: '; ?(KFAPWA) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 8.9" (3rd Gen) Wan'
        device: 'Kindle Fire HDX 8.9" (3rd Gen) Wan'
      - regex: '; ?(KFAPWI) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 8.9" (3rd Gen)'
        device: 'Kindle Fire HDX 8.9" (3rd Gen)'
      - regex: '; ?(KFSOWI) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HD 7" (3rd Gen)'
        device: 'Kindle Fire HD 7" (3rd Gen)'
      - regex: '; ?(KFTHWI) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 7"'
        device: 'Kindle Fire HDX 7"'
      - regex: '; ?(KFTHWA) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HDX 7" Wan'
        device: 'Kindle Fire HDX 7" Wan'
      - regex: '; ?(KFJWA) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HD 8.9" (2nd Gen) Wan'
        device: 'Kindle Fire HD 8.9" (2nd Gen) Wan'
      - regex: '; ?(KFJWI) Build\b'
        brand: 'Amazon'
        model: 'Kindle Fire HD 8.9" (2nd Gen)'
        device: 'Kindle Fire HD 8.9" (2nd Gen)'
      - regex: '; ?(SD4930UR) Build\b'
        device: 'Fire Phone'
        brand: 'Amazon'
        model: 'Fire Phone'
      - regex: '; ?Amazon ([^;/]+) Build\b'
        device: '$1'
        brand: 'Amazon'
        model: '$1'
      - regex: '; ?(Kindle) Build\b'
        device: 'Kindle'
        brand: 'Amazon'
        model: 'Kindle'
      - regex: '; ?(Silk)/(\d+)\.(\d+)(?:\.([0-9\-]+))? Build\b'
        device: 'Kindle Fire'
        brand: 'Amazon'
        model: 'Kindle Fire$2'
      - regex: ' (Kindle)/(\d+\.\d+)'
        device: 'Kindle'
        brand: 'Amazon'
        model: '$1 $2'
      - regex: ' (Silk|Kindle)/(\d+)\.'
        device: 'Kindle'
        brand: 'Amazon'
        model: 'Kindle'
      - regex: '; (AFTB|AFTM) Build'
        device: '$1'
        brand: 'Amazon'
        model: '$1'

      #########
      # Devices from chinese manufacturer(s)
      # @note: identified by x-wap-profile http://218.249.47.94/Xianghe/.*
      #########
      - regex: '(sprd)\-([^/]+)/'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      # @ref: http://eshinechina.en.alibaba.com/
      - regex: '; *(H\d{2}00\+?) Build'
        device: '$1'
        brand: 'Hero'
        model: '$1'
      - regex: '; *(iphone|iPhone5) Build/'
        device: 'Xianghe $1'
        brand: 'Xianghe'
        model: '$1'
      - regex: '; *([^;/]+(?:v\d{2}_[a-z]{2,4}|_jbla?))[^;/]+ Build/'
        device: 'Xianghe $1'
        brand: 'Xianghe'
        model: '$1'

      #########
      # Cellular
      # @ref:
      # @note: Operator branded devices
      #########
      - regex: '\bUSCCHTC[_\-]?([^ ;/\)]+)'
        device: '$1'
        brand: 'HTC'
        model: '$1'
      - regex: '\bUSCC[_\-]?([^ ;/\)]+)'
        device: '$1'
        brand: 'Cellular'
        model: '$1'

  ######################################################################
  # Windows Phone Parsers
  ######################################################################
  - regex: 'Windows Phone|WPDesktop'
    group:

      #########
      # Alcatel Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:ALCATEL)[^;]*; *([^;,\)]+)'
        device: 'Alcatel $1'
        brand: 'Alcatel'
        model: '$1'

      #########
      # Asus Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?|WpsLondonTest; ?)?(?:ASUS|Asus)[^;]*; *([^;,\)]+)'
        device: 'Asus $1'
        brand: 'Asus'
        model: '$1'

      #########
      # Dell Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:DELL|Dell)[^;]*; *([^;,\)]+)'
        device: 'Dell $1'
        brand: 'Dell'
        model: '$1'

      #########
      # HTC Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?|WpsLondonTest; ?)?(?:HTC|Htc|HTC_blocked[^;]*)[^;]*; *(?:HTC)?([^;,\)]+)'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'
      - regex: 'WPDesktop; (Windows Phone 8[SX] by HTC)'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'
      - regex: '(LEO70)'
        device: 'HTC $1'
        brand: 'HTC'
        model: '$1'

      #########
      # Huawei Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:HUAWEI)[^;]*; *(?:HUAWEI )?([^;,\)]+)'
        device: 'Huawei $1'
        brand: 'Huawei'
        model: '$1'
      - regex: 'WPDesktop; (W1-U00)'
        device: 'Huawei $1'
        brand: 'Huawei'
        model: '$1'

      #########
      # LG Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:LG|Lg)[^;]*; *(?:LG[ \-])?([^;,\)]+)'
        device: 'LG $1'
        brand: 'LG'
        model: '$1'

      #########
      # Noka Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:NOKIA|Nokia)[^;]*; *(?:NOKIA ?|Nokia ?|LUMIA ?|[Ll]umia ?)*(\d{3,}[^;\)]*)'
        device: 'Lumia $1'
        brand: 'Nokia'
        model: 'Lumia $1'
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:NOKIA|Nokia)[^;]*; *(RM-\d{3,})'
        device: 'Nokia $1'
        brand: 'Nokia'
        model: '$1'
      - regex: '(?:Windows Phone Search.*|WPDesktop;) *(?:NOKIA|Nokia); *(Lumia[^;\)]+)'
        device: 'Nokia $1'
        brand: 'Nokia'
        model: '$1'
      - regex: 'WPDesktop;(?: NOKIA; Nokia| NOKIA;| Nokia)? (\d+[^;\)]+)'
        device: 'Nokia Lumia $1'
        brand: 'Nokia'
        model: 'Lumia $1'
      - regex: 'Windows Phone Search.*NOKIA;(?:Nokia )?(\d+[^;\)]+)'
        device: 'Nokia Lumia $1'
        brand: 'Nokia'
        model: 'Lumia $1'

      #########
      # Microsoft Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?)?(?:Microsoft(?: Corporation)?)[^;]*; *([^;,\)]+)'
        device: 'Microsoft $1'
        brand: 'Microsoft'
        model: '$1'
      - regex: '(?:Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)]|WPDesktop;) ?(?:ARM; ?Touch; ?|Touch; ?)? *((?:LUMIA ?|[Ll]umia ?)[^;\)]+)'
        device: 'Microsoft $1'
        brand: 'Microsoft'
        model: '$1'

      #########
      # Prestigio Windows Phones
      #########
      - regex: 'WPDesktop; *(?:PRESTIGIO;)? (PSP[^;\)]+)'
        device: 'Prestigio $1'
        brand: 'Prestigio'
        model: '$1'

      #########
      # Samsung Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?|WpsLondonTest; ?)?(?:SAMSUNG)[^;]*; *(?:SAMSUNG )?([^;,\.\)]+)'
        device: 'Samsung $1'
        brand: 'Samsung'
        model: '$1'
      - regex: 'WPDesktop; *(?:SAMSUNG;)? ((?:GT-|SGH-)[^;\)]+)'
        device: 'Samsung $1'
        brand: 'Samsung'
        model: '$1'

      #########
      # Toshiba Windows Phones
      #########
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?|Touch; ?|WpsLondonTest; ?)?(?:TOSHIBA|FujitsuToshibaMobileCommun)[^;]*; *([^;,\)]+)'
        device: 'Toshiba $1'
        brand: 'Toshiba'
        model: '$1'

      #########
      # Generic Windows Phones
      #########
      ## - regex: '\(compatible; MSIE [^;]+; Windows Phone [^;]+; Trident/[^;]+; ?(?:ARM; Touch; ?)?IEMobile/[^;]+; ?(?:ARM; ?Touch; ?|Touch; ?|WpsLondonTest; ?)?([^;]+); *([^;,\)]+)'
      - regex: 'Windows Phone [^;]+; .*?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch; ?(?:rv:\d+; )?|Touch; ?|WpsLondonTest; ?)?([^;]+); *([^;,\)]+)'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      - regex: 'WPDesktop; ([^;]+); *([^;,\)]+)'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      - regex: 'Windows Phone Search \(Windows Phone OS [^;]+;([^;]+);([^;]+);'
        device: '$1 $2'
        brand: '$1'
        model: '$2'

  ######################################################################
  # Other Devices Parser
  ######################################################################

  #########
  # Samsung Bada Phones
  #########
  - regex: '(?:^|; )SAMSUNG\-([A-Za-z0-9\-]+).* Bada/'
    device: 'Samsung $1'
    brand: 'Samsung'
    model: '$1'

  #########
  # Firefox OS
  #########
  - regex: '\(Mobile; ALCATEL ?(One|ONE) ?(Touch|TOUCH) ?([^;/]+)(?:/[^;]+)?; rv:[^\)]+\) Gecko/[^\/]+ Firefox/'
    device: 'Alcatel $1 $2 $3'
    brand: 'Alcatel'
    model: 'One Touch $3'
  - regex: '\(Mobile; (?:ZTE([^;]+)|(OpenC)|(Open) (C)); rv:[^\)]+\) Gecko/[^\/]+ Firefox/'
    regex_flag: 'i'
    device: 'ZTE $1$2$3$4'
    brand: 'ZTE'
    model: '$1$2$3$4'

  ##########
  # NOKIA
  # @note: NokiaN8-00 comes before iphone. Sometimes spoofs iphone
  ##########
  - regex: 'nokia|symbian|lumia'
    regex_flag: 'i'
    group:
      - regex: 'Nokia(N[0-9]+)([A-z_\-][A-z0-9_\-]*)'
        device: 'Nokia $1'
        brand: 'Nokia'
        model: '$1$2'
      - regex: '(?:Lumia|NOKIA; Nokia) ([A-Za-z0-9\-]+)'
        device: 'Lumia $1'
        brand: 'Nokia'
        model: 'Lumia $1'
      - regex: '(?:NOKIA|[Nn]okia)+(?:\-| *|; *)(?:([A-Za-z0-9]+)\-[0-9a-f]{32}|([A-Za-z0-9\-]+)(?:UCBrowser)|([A-Za-z0-9\-]+))'
        device: 'Nokia $1$2$3'
        brand: 'Nokia'
        model: '$1$2$3'
      # UCWEB Browser on Symbian
      - regex: '\(Symbian; U; S60 V5; [A-z]{2}\-[A-z]{2}; (SonyEricsson|Samsung|Nokia|LG)([^;/]+)\)'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      # Nokia Symbian
      - regex: '\(Symbian(?:/3)?; U; ([^;]+);'
        device: 'Nokia $1'
        brand: 'Nokia'
        model: '$1'

  ##########
  # BlackBerry
  # @ref: http://www.useragentstring.com/pages/BlackBerry/
  ##########
  - regex: 'blackberry|rim|bb10;'
    regex_flag: 'i'
    group:
      - regex: 'BB10; ([A-Za-z0-9\- ]+)\)'
        device: 'BlackBerry $1'
        brand: 'BlackBerry'
        model: '$1'
        type: 'smartphone'
      - regex: 'Play[Bb]ook.+RIM Tablet OS'
        device: 'BlackBerry Playbook'
        brand: 'BlackBerry'
        model: 'Playbook'
        type: 'tablet'
      - regex: 'Black[Bb]erry *?([a-z0-9]+)'
        device: 'BlackBerry $1'
        brand: 'BlackBerry'
        model: '$1'
      - regex: 'Black[Bb]erry'
        device: 'BlackBerry $1'
        brand: 'BlackBerry'
        model: '$1'

  ##########
  # PALM / HP
  # @note: some palm devices must come before iphone. sometimes spoofs iphone in ua
  ##########
  - regex: '\b(Pre|Pixi|webOS|hpwOS|Palm|iPAQ|Treo|Tungsten|TouchPad|Xiino)'
    group:
      - regex: '(Pre|Pixi)/\d+\.\d+'
        device: 'Palm $1'
        brand: 'Palm'
        model: '$1'
        type: 'smartphone'
      - regex: 'Palm([0-9]+)'
        device: 'Palm $1'
        brand: 'Palm'
        model: '$1'
      - regex: '(Tungsten)'
        device: 'Palm $1'
        brand: 'Palm'
      - regex: '(Xiino)'
        device: 'Palm'
        brand: 'Palm'
        model: ' '
      - regex: 'Treo([A-Za-z0-9]+)'
        device: 'Palm Treo $1'
        brand: 'Palm'
        model: 'Treo $1'
      - regex: 'webOS.*(P160U(?:NA)?)/(\d+).(\d+)'
        device: 'HP Veer'
        brand: 'HP'
        model: 'Veer'
        type: 'tablet'
      - regex: '(Touch[Pp]ad)/\d+\.\d+'
        device: 'HP TouchPad'
        brand: 'HP'
        model: 'TouchPad'
        type: 'tablet'
      - regex: 'HPiPAQ([A-Za-z0-9]+)/\d+.\d+'
        device: 'HP iPAQ $1'
        brand: 'HP'
        model: 'iPAQ $1'
      - regex: 'PDA; (PalmOS)/sony/model ([a-z]+)/Revision'
        device: '$1'
        brand: 'Sony'
        model: '$1 $2'

  ##########
  # AppleTV
  # No built in browser that I can tell
  # Stack Overflow indicated iTunes-AppleTV/4.1 as a known UA for app available and I'm seeing it in live traffic
  ##########
  - regex: 'Apple\s?TV(\d,\d)?(?:.* \((\d)[;\)])?'
    device: 'AppleTV'
    brand: 'Apple'
    model: 'AppleTV$1$2'

  #########
  # Tesla Model S
  #########
  - regex: '(QtCarBrowser)'
    device: 'Tesla Model S'
    brand: 'Tesla'
    model: 'Model S'
    type: 'car'

  ##########
  # iSTUFF
  # @note: complete but probably catches spoofs
  #   ipad and ipod must be parsed before iphone
  #   cannot determine specific device type from ua string. (3g, 3gs, 4, etc)
  ##########
  - regex: 'iPhone|iPad|iPod|CFNetwork|Darwin'
    group:
      # @note: on some ua the device can be identified e.g. iPhone5,1
      - regex: '((?:iPhone|iPad|iPod)\d+,\d+)'
        device: '$1'
        brand: 'Apple'
        model: '$1'
      # @note: iPad needs to be before iPhone
      - regex: '(iPad)(?:;| Simulator;)'
        device: '$1'
        brand: 'Apple'
        model: '$1'
      - regex: '(iPod)(?:;| touch;| Simulator;)'
        device: '$1'
        brand: 'Apple'
        model: '$1'
      - regex: '(iPhone)(?:;| Simulator;)'
        device: '$1'
        brand: 'Apple'
        model: '$1'
      # @note: desktop applications show device info
      - regex: 'CFNetwork/.* Darwin/\d.*\(((?:Mac|iMac|PowerMac|PowerBook)[^\d]*)(\d+)(?:,|%2C)(\d+)'
        device: '$1$2,$3'
        brand: 'Apple'
        model: '$1$2,$3'
      # @note: OSx applications do not show device info
      - regex: 'CFNetwork/.* Darwin/\d.*\((?:i386|x86_64)\)'
        device: 'iOS-Device'
        brand: 'Apple'
        model: 'Mac OS X-Device'
      # @note: iOS applications do not show device info
      - regex: 'CFNetwork/.* Darwin/\d'
        device: 'iOS-Device'
        brand: 'Apple'
        model: 'iOS-Device'

  ##########
  # Acer
  ##########
  - regex: 'acer_([A-Za-z0-9]+)_'
    device: 'Acer $1'
    brand: 'Acer'
    model: '$1'

  ##########
  # Alcatel
  ##########
  - regex: '(?:alcatel[ _\-])(?:(?:one[ _\-]?touch[ _\-]|ot[ \-]))((?:(?!UNTRUSTED|Linux|Firmware|AppleWebKit|Build|UCWEB|[;/\(\)_\-]).)+)'
    regex_flag: 'i'
    device: 'Alcatel One Touch $1'
    brand: 'Alcatel'
    model: 'One Touch $1'
  - regex: '(?:ALCATEL|Alcatel)-([A-Za-z0-9\-]+)'
    device: 'Alcatel $1'
    brand: 'Alcatel'
    model: '$1'

  ##########
  # Amoi
  ##########
  - regex: '(?:Amoisonic|Amoi)[_\- /]?([a-z0-9]+)'
    regex_flag: 'i'
    device: 'Amoi $1'
    brand: 'Amoi'
    model: '$1'

  #########
  # Garmin-Asus
  #########
  - regex: 'garmin-asus-([^/]+)'
    regex_flag: 'i'
    device: 'Garmin $1'
    brand: 'Garmin-Asus'
    model: '$1'

  ##########
  # Asus
  ##########
  - regex: '(?:; |\/|^)((?:Transformer (?:Pad|Prime) |Transformer |PadFone[ _]?)[A-Za-z0-9]*)'
    device: 'Asus $1'
    brand: 'Asus'
    model: '$1'
  - regex: '(?:asus.*?ASUS|Asus|ASUS|asus)[\- ;]*((?:Transformer (?:Pad|Prime) |Transformer |Padfone |Nexus[ _])?[A-Za-z0-9]+)'
    device: 'Asus $1'
    brand: 'Asus'
    model: '$1'

  ##########
  # Bird
  ##########
  - regex: '\bBIRD[ \-\.]([A-Za-z0-9]+)'
    device: 'Bird $1'
    brand: 'Bird'
    model: '$1'

  ##########
  # Dell
  ##########
  - regex: '\bDell ([A-Za-z0-9]+)'
    device: 'Dell $1'
    brand: 'Dell'
    model: '$1'

  ##########
  # DoCoMo
  ##########
  - regex: 'DoCoMo|FOMA'
    group:
    - regex: 'DoCoMo/2\.0 ([A-Za-z0-9]+)'
      device: 'DoCoMo $1'
      brand: 'DoCoMo'
      model: '$1'
    - regex: '([A-Za-z0-9]+)_W\;FOMA'
      device: 'DoCoMo $1'
      brand: 'DoCoMo'
      model: '$1'
    - regex: '([A-Za-z0-9]+)\;FOMA'
      device: 'DoCoMo $1'
      brand: 'DoCoMo'
      model: '$1'

  ##########
  # htc
  ##########
  - regex: '\b(?:HTC/|HTC/[a-z0-9]+/)?HTC[ _\-;]? *(.*?)(?:-?Mozilla|fingerPrint|[;/\(\)]|$)'
    regex_flag: 'i'
    device: 'HTC $1'
    brand: 'HTC'
    model: '$1'

  ##########
  # Huawei
  ##########
  - regex: 'huawei|vodafone'
    regex_flag: 'i'
    group:
    - regex: 'Huawei([A-Za-z0-9]+)'
      device: 'Huawei $1'
      brand: 'Huawei'
      model: '$1'
    - regex: 'HUAWEI-([A-Za-z0-9]+)'
      device: 'Huawei $1'
      brand: 'Huawei'
      model: '$1'
    - regex: 'vodafone([A-Za-z0-9]+)'
      device: 'Huawei Vodafone $1'
      brand: 'Huawei'
      model: 'Vodafone $1'

  ##########
  # i-mate
  ##########
  - regex: 'i\-mate ([A-Za-z0-9]+)'
    device: 'i-mate $1'
    brand: 'i-mate'
    model: '$1'

  ##########
  # kyocera
  ##########
  - regex: 'Kyocera|KWC'
    group:
    - regex: 'Kyocera\-([A-Za-z0-9]+)'
      device: 'Kyocera $1'
      brand: 'Kyocera'
      model: '$1'
    - regex: 'KWC\-([A-Za-z0-9]+)'
      device: 'Kyocera $1'
      brand: 'Kyocera'
      model: '$1'

  ##########
  # lenovo
  ##########
  - regex: '\b(?:[Ll]enovo|LENOVO)+[ _\-]?([^,;:/ \)]+)'
    device: 'Lenovo $1'
    brand: 'Lenovo'
    model: '$1'

  ##########
  # HbbTV (European and Australian standard)
  # written before the LG regexes, as LG is making HbbTV too
  ##########
  - regex: 'HbbTV'
    group:
      - regex: '(HbbTV)/[0-9]+\.[0-9]+\.[0-9]+ \([^;]*; *(LG)E *; *([^;]*) *;[^;]*;[^;]*;\)'
        device: '$1'
        brand: '$2'
        model: '$3'
        type: 'tv'
      - regex: '(HbbTV)/1\.1\.1.*CE-HTML/1\.\d;Vendor/([^;]+);(?:.*SW-Version/.*(LF[^;]+);)?'
        device: '$1'
        brand: '$2'
        model: '$3'
        type: 'tv'
      - regex: '(HbbTV)(?:/1\.1\.1)?(?: ?\(;;;;;\))?; *CE-HTML(?:/1\.\d)?; *([^ ]+) ([^;]+);'
        device: '$1'
        brand: '$2'
        model: '$3'
        type: 'tv'
      - regex: '(HbbTV)/1\.1\.1 \(;;;;;\) Maple_2011'
        device: '$1'
        brand: 'Samsung'
        type: 'tv'
      - regex: '(HbbTV)/[0-9]+\.[0-9]+\.[0-9]+ \([^;]*; *(?:CUS:([^;]*)|([^;]+)) *; *([^;]*) *;.*;'
        device: '$1'
        brand: '$2$3'
        model: '$4'
        type: 'tv'
      - regex: '(HbbTV)/[0-9]+\.[0-9]+\.[0-9]+'
        device: '$1'
        type: 'tv'

  ##########
  # LGE NetCast TV
  ##########
  - regex: 'LGE; (?:Media\/)?([^;]*);[^;]*;[^;]*;?\); "?LG NetCast(\.TV|\.Media|)-\d+'
    device: 'NetCast$2'
    brand: 'LG'
    model: '$1'
    type: 'tv'

  ##########
  # InettvBrowser, DirectFB, SmartTV
  ##########
  - regex: 'InettvBrowser|TSBNetTV|NETTV|HBBTV|DirectFB|SmartTV|SMART-TV'
    group:
      - regex: 'InettvBrowser/[0-9]+\.[0-9A-Z]+ \([^;]*;(Sony)([^;]*);[^;]*;[^\)]*\)'
        device: 'Inettv'
        brand: '$1'
        model: '$2'
        type: 'tv'
      - regex: 'InettvBrowser/[0-9]+\.[0-9A-Z]+ \([^;]*;([^;]*);[^;]*;[^\)]*\)'
        device: 'Inettv'
        brand: 'Generic_Inettv'
        model: '$1'
        type: 'tv'
      - regex: '(SMART-TV|SmartTV)'
        brand: 'Samsung'
        type: 'tv'
      - regex: '(InettvBrowser|TSBNetTV|NETTV|HBBTV|DirectFB)'
        device: 'Inettv'
        brand: 'Generic_Inettv'
        type: 'tv'

  ##########
  # lg
  ##########
  # LG Symbian Phones
  - regex: '\bLG'
    regex_flag: 'i'
    group:
      - regex: 'Series60/\d\.\d (LG)[\-]?([A-Za-z0-9 \-]+)'
        device: '$1 $2'
        brand: '$1'
        model: '$2'
      # other LG phones
      - regex: '; *(LG-)([A-Z]{1,2}\d{2,}[^,;/\)\(]*?)(?:Build| V\d+|[,;/\)\(]|$)'
        device: '$1$2'
        brand: 'LG'
        model: '$2'
      - regex: '\b(?:LGE[ \-]LG\-(?:AX)?|LGE |LGE?-LG|LGE?[ \-]|LG[ /\-]|lg[\-])([A-Za-z0-9]+)\b'
        device: 'LG $1'
        brand: 'LG'
        model: '$1'
      - regex: '(?:^LG[\-]?|^LGE[\-/]?)([A-Za-z]+[0-9]+[A-Za-z]*)'
        device: 'LG $1'
        brand: 'LG'
        model: '$1'
      - regex: '^LG([0-9]+[A-Za-z]*)'
        device: 'LG $1'
        brand: 'LG'
        model: '$1'

  ##########
  # microsoft
  ##########
  - regex: '(KIN\.[^ ]+) (\d+)\.(\d+)'
    device: 'Microsoft $1'
    brand: 'Microsoft'
    model: '$1'
  - regex: '(?:MSIE|XBMC).*\b(Xbox)\b'
    device: '$1'
    brand: 'Microsoft'
    model: '$1'
  - regex: '; ARM; Trident/6\.0; Touch[\);]'
    device: 'Microsoft Surface RT'
    brand: 'Microsoft'
    model: 'Surface RT'

  ##########
  # motorola
  ##########
  - regex: 'mot[o-]'
    regex_flag: 'i'
    group:
    - regex: 'Motorola\-([A-Za-z0-9]+)'
      device: 'Motorola $1'
      brand: 'Motorola'
      model: '$1'
    - regex: 'MOTO\-([A-Za-z0-9]+)'
      device: 'Motorola $1'
      brand: 'Motorola'
      model: '$1'
    - regex: 'MOT\-([A-z0-9][A-z0-9\-]*)'
      device: 'Motorola $1'
      brand: 'Motorola'
      model: '$1'

  ##########
  # nintendo
  ##########
  - regex: 'Nintendo'
    group:
    - regex: 'Nintendo WiiU'
      device: 'Nintendo Wii U'
      brand: 'Nintendo'
      model: 'Wii U'
    - regex: 'Nintendo (DS|3DS|DSi|Wii);'
      device: 'Nintendo $1'
      brand: 'Nintendo'
      model: '$1'

  ##########
  # pantech
  ##########
  - regex: '(?:Pantech|PANTECH)[ _-]?([A-Za-z0-9\-]+)'
    device: 'Pantech $1'
    brand: 'Pantech'
    model: '$1'

  ##########
  # philips
  ##########
  - regex: 'Philips([A-Za-z0-9]+)'
    device: 'Philips $1'
    brand: 'Philips'
    model: '$1'
  - regex: 'Philips ([A-Za-z0-9]+)'
    device: 'Philips $1'
    brand: 'Philips'
    model: '$1'

  #########
  # Sprint (Operator Branded Devices)
  # @ref:http://www.sprint.com
  #########
  - regex: '\b(Sprint)[: ]([^;,/ ]+)'
    device: '$1$2'
    brand: 'Sprint'
    model: '$2'

  ##########
  # Samsung
  ##########
  - regex: 'samsung'
    regex_flag: 'i'
    group:
    # Samsung Symbian Devices
    - regex: 'SymbianOS/9\.\d.* Samsung[/\-]([A-Za-z0-9 \-]+)'
      device: 'Samsung $1'
      brand: 'Samsung'
      model: '$1'
    - regex: '(Samsung)(SGH)(i[0-9]+)'
      device: '$1 $2$3'
      brand: '$1'
      model: '$2-$3'
    - regex: 'SAMSUNG-ANDROID-MMS/([^;/]+)'
      device: '$1'
      brand: 'Samsung'
      model: '$1'
    # Other Samsung
    #- regex: 'SAMSUNG(?:; |-)([A-Za-z0-9\-]+)'
    - regex: 'SAMSUNG(?:; |[ -/])([A-Za-z0-9\-]+)'
      regex_flag: 'i'
      device: 'Samsung $1'
      brand: 'Samsung'
      model: '$1'

  ##########
  # Sega
  ##########
  - regex: '(Dreamcast)'
    device: 'Sega $1'
    brand: 'Sega'
    model: '$1'

  ##########
  # Siemens mobile
  ##########
  - regex: '^SIE-([A-Za-z0-9]+)'
    device: 'Siemens $1'
    brand: 'Siemens'
    model: '$1'

  ##########
  # Softbank
  ##########
  - regex: 'Softbank/[12]\.0/([A-Za-z0-9]+)'
    device: 'Softbank $1'
    brand: 'Softbank'
    model: '$1'

  ##########
  # SonyEricsson
  ##########
  - regex: 'SonyEricsson([A-Za-z0-9]+)/'
    device: 'Ericsson $1'
    brand: 'SonyEricsson'
    model: '$1'


  ##########
  # Sony PlayStation
  # @ref: http://playstation.com
  # The Vita spoofs the Kindle
  ##########
  - regex: 'PlayStation (\d+)'
    regex_flag: 'i'
    device: 'PlayStation $1'
    brand: 'Sony'
    model: 'PlayStation $1'
    type: 'tv'
  - regex: '(PlayStation (?:Portable|Vita))'
    device: '$1'
    brand: 'Sony'
    model: '$1'
    type: 'console'

  ##########
  # Sony
  ##########
  - regex: 'Sony([^ ]+) '
    device: 'Sony $1'
    brand: 'Sony'
    model: '$1'

  ##########
  # Amazon
  ##########
  - regex: ' (Kindle)/(\d+\.\d+)'
    device: 'Kindle'
    brand: 'Amazon'
    model: '$1 $2'
  - regex: ' (Silk|Kindle)/(\d+)\.'
    device: 'Kindle'
    brand: 'Amazon'
    model: 'Kindle'

  ##########
  # WeTab
  # @ref: http://wetab.mobi/
  ##########
  - regex: '(WeTab)-Browser'
    device: '$1'
    brand: 'WeTab'
    model: '$1'

  #########
  # Puffin Browser Device detect
  # A=Android, I=iOS, P=Phone, T=Tablet
  # AT=Android+Tablet
  #########
  - regex: 'Puffin/[\d\.]+IT'
    device: 'iPad'
    brand: 'Apple'
    model: 'iPad'
  - regex: 'Puffin/[\d\.]+IP'
    device: 'iPhone'
    brand: 'Apple'
    model: 'iPhone'
  - regex: 'Puffin/[\d\.]+AT'
    device: 'Generic Tablet'
    brand: 'Generic'
    model: 'Tablet'
  - regex: 'Puffin/[\d\.]+AP'
    device: 'Generic Smartphone'
    brand: 'Generic'
    model: 'Smartphone'

  #########
  # Android General Device Matching (far from perfect)
  #########
  - regex: 'Android[\- ][\d]+\.[\d]+; [A-Za-z]{2}\-[A-Za-z]{0,2}; WOWMobile (.+) Build'
    brand: 'Generic_Android'
    model: '$1'
  - regex: 'Android[\- ][\d]+\.[\d]+\-update1; [A-Za-z]{2}\-[A-Za-z]{0,2} *; *(.+?) Build'
    brand: 'Generic_Android'
    model: '$1'
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}; *[A-Za-z]{2}[_\-][A-Za-z]{0,2}\-? *; *(.+?) Build'
    brand: 'Generic_Android'
    model: '$1'
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}; *[A-Za-z]{0,2}\- *; *(.+?) Build'
    brand: 'Generic_Android'
    model: '$1'
  # No build info at all - "Build" follows locale immediately
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}; *[a-z]{0,2}[_\-]?[A-Za-z]{0,2};? Build.* Mobile Safari'
    device: 'Generic Smartphone'
    brand: 'Generic'
    model: 'Smartphone'
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}; *[a-z]{0,2}[_\-]?[A-Za-z]{0,2};? Build'
    device: 'Generic Tablet'
    brand: 'Generic'
    model: 'Tablet'
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}; *\-?[A-Za-z]{2}; *(.+?) Build'
    brand: 'Generic_Android'
    model: '$1'
  - regex: 'Android[\- ][\d]+(?:\.[\d]+){1,2}(?:;.*)?; *(.+?) Build'
    brand: 'Generic_Android'
    model: '$1'

  ##########
  # Google TV
  ##########
  - regex: '(GoogleTV)'
    brand: 'Generic_Inettv'
    model: '$1'

  ##########
  # WebTV
  ##########
  - regex: '(WebTV)/\d+.\d+'
    brand: 'Generic_Inettv'
    model: '$1'

  ##########
  # Generic Tablet
  ##########
  - regex: '(Android 3\.\d|Opera Tablet|Tablet; .+Firefox/|Android.*(?:Tab|Pad))'
    regex_flag: 'i'
    device: 'Generic Tablet'
    brand: 'Generic'
    model: 'Tablet'

  ##########
  # Generic Smart Phone
  ##########
  - regex: '(Symbian|\bS60(Version|V\d)|\bS60\b|\((Series 60|Windows Mobile|Palm OS|Bada); Opera Mini|Windows CE|Opera Mobi|BREW|Brew|Mobile; .+Firefox/|iPhone OS|Android|MobileSafari|Windows *Phone|\(webOS/|PalmOS)'
    device: 'Generic Smartphone'
    brand: 'Generic'
    model: 'Smartphone'
  - regex: '(hiptop|avantgo|plucker|xiino|blazer|elaine)'
    regex_flag: 'i'
    device: 'Generic Smartphone'
    brand: 'Generic'
    model: 'Smartphone'

  ##########
  # Spiders (this is hack...)
  # Sort by length
  ##########
  - regex: '(bot|zao|borg|DBot|oegp|silk|Xenu|zeal|^NING|CCBot|crawl|htdig|lycos|slurp|teoma|voila|yahoo|^Java/|^JNLP/|Daumoa|Genieo|ichiro|larbin|msnbot|msrbot|pompos|Scrapy|snappy|speedy|spider|^vortex|bingbot|crawler|favicon|furlbot|gigabot|indexer|openbot|polybot|Riddler|scooter|scraper|scrubby|seekbot|WhatWeb|WinHTTP|^voyager|archiver|blitzbot|Icarus6j|mogimogi|NerdyBot|Netvibes|altavista|charlotte|findlinks|ProoXiBot|Retreiver|SeznamBot|TLSProber|WordPress|EtaoSpider|PaperLiBot|SputnikBot|Squrl Java|wsr\-agent|A6\-Indexer|baiduspider|netresearch|searchsight|YisouSpider|ICC\-Crawler|MsnBot-Media|http%20client|Python-urllib|converacrawler|dataparksearch|AppEngine-Google|fast\-webcrawler|Sogou Pic Spider|semanticdiscovery|Innovazion Crawler|facebookexternalhit|Google-HTTP-Java-Client|Google.*/\+/web/snippet|ELB-HealthChecker|SiteScope)'
    regex_flag: 'i'
    device: 'Spider'
    brand: 'Spider'
    model: 'Desktop'

  ##########
  # Generic Feature Phone
  # take care to do case insensitive matching
  ##########
  - regex: '^(1207|3gso|4thp|501i|502i|503i|504i|505i|506i|6310|6590|770s|802s|a wa|acer|acs\-|airn|alav|asus|attw|au\-m|aur |aus |abac|acoo|aiko|alco|alca|amoi|anex|anny|anyw|aptu|arch|argo|bmobile|bell|bird|bw\-n|bw\-u|beck|benq|bilb|blac|c55/|cdm\-|chtm|capi|comp|cond|dall|dbte|dc\-s|dica|ds\-d|ds12|dait|devi|dmob|doco|dopo|dorado|el(?:38|39|48|49|50|55|58|68)|el[3456]\d{2}dual|erk0|esl8|ex300|ez40|ez60|ez70|ezos|ezze|elai|emul|eric|ezwa|fake|fly\-|fly_|g\-mo|g1 u|g560|gf\-5|grun|gene|go.w|good|grad|hcit|hd\-m|hd\-p|hd\-t|hei\-|hp i|hpip|hs\-c|htc |htc\-|htca|htcg)'
    regex_flag: 'i'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'
  - regex: '^(htcp|htcs|htct|htc_|haie|hita|huaw|hutc|i\-20|i\-go|i\-ma|i\-mobile|i230|iac|iac\-|iac/|ig01|im1k|inno|iris|jata|kddi|kgt|kgt/|kpt |kwc\-|klon|lexi|lg g|lg\-a|lg\-b|lg\-c|lg\-d|lg\-f|lg\-g|lg\-k|lg\-l|lg\-m|lg\-o|lg\-p|lg\-s|lg\-t|lg\-u|lg\-w|lg/k|lg/l|lg/u|lg50|lg54|lge\-|lge/|leno|m1\-w|m3ga|m50/|maui|mc01|mc21|mcca|medi|meri|mio8|mioa|mo01|mo02|mode|modo|mot |mot\-|mt50|mtp1|mtv |mate|maxo|merc|mits|mobi|motv|mozz|n100|n101|n102|n202|n203|n300|n302|n500|n502|n505|n700|n701|n710|nec\-|nem\-|newg|neon)'
    regex_flag: 'i'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'
  - regex: '^(netf|noki|nzph|o2 x|o2\-x|opwv|owg1|opti|oran|ot\-s|p800|pand|pg\-1|pg\-2|pg\-3|pg\-6|pg\-8|pg\-c|pg13|phil|pn\-2|pt\-g|palm|pana|pire|pock|pose|psio|qa\-a|qc\-2|qc\-3|qc\-5|qc\-7|qc07|qc12|qc21|qc32|qc60|qci\-|qwap|qtek|r380|r600|raks|rim9|rove|s55/|sage|sams|sc01|sch\-|scp\-|sdk/|se47|sec\-|sec0|sec1|semc|sgh\-|shar|sie\-|sk\-0|sl45|slid|smb3|smt5|sp01|sph\-|spv |spv\-|sy01|samm|sany|sava|scoo|send|siem|smar|smit|soft|sony|t\-mo|t218|t250|t600|t610|t618|tcl\-|tdg\-|telm|tim\-|ts70|tsm\-|tsm3|tsm5|tx\-9|tagt)'
    regex_flag: 'i'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'
  - regex: '^(talk|teli|topl|tosh|up.b|upg1|utst|v400|v750|veri|vk\-v|vk40|vk50|vk52|vk53|vm40|vx98|virg|vertu|vite|voda|vulc|w3c |w3c\-|wapj|wapp|wapu|wapm|wig |wapi|wapr|wapv|wapy|wapa|waps|wapt|winc|winw|wonu|x700|xda2|xdag|yas\-|your|zte\-|zeto|aste|audi|avan|blaz|brew|brvw|bumb|ccwa|cell|cldc|cmd\-|dang|eml2|fetc|hipt|http|ibro|idea|ikom|ipaq|jbro|jemu|jigs|keji|kyoc|kyok|libw|m\-cr|midp|mmef|moto|mwbp|mywa|newt|nok6|o2im|pant|pdxg|play|pluc|port|prox|rozo|sama|seri|smal|symb|treo|upsi|vx52|vx53|vx60|vx61|vx70|vx80|vx81|vx83|vx85|wap\-|webc|whit|wmlb|xda\-|xda_)'
    regex_flag: 'i'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'
  - regex: '^(Ice)$'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'
  - regex: '(wap[\-\ ]browser|maui|netfront|obigo|teleca|up\.browser|midp)'
    regex_flag: 'i'
    device: 'Generic Feature Phone'
    brand: 'Generic'
    model: 'Feature Phone'


#### Device Model ####
device_model_parsers:

  - regex: '^[a-z]{2}-; *'
    replace: ''

  #########
  # Huawei
  # @ref: http://www.huaweidevice.com
  # @note: Needs to be before HTC due to Desire HD Build on U8815
  #########
  - regex: 'huawei|u\d{4}|ideos|honor|ascend|mediapad'
    regex_flag: 'i'
    group:
      # disable serial
      - regex: '([0-9A-F\-]{36,})'
        replace: ''
      - regex: '(MediaPad[^;]*)'
        brand: 'Huawei'
      - regex: '^(?:HUAWEI[ _\-]?|Huawei[ _\-]?)?([Uu][89]\d{3}(?:(?!B\d{3}).)*)'
        brand: 'Huawei'
      - regex: '((?:Ideos|IDEOS|HONOR) [^;/]+)'
        brand: 'Huawei'
      - regex: '(?:HUAWEI[ _]?|Huawei[ _])?(Ascend[ _][^;/]+)'
        brand: 'Huawei'
      - regex: '(?:HUAWEI[ _\-]?|Huawei[ _\-]?)+([^;/]+)'
        brand: 'Huawei'

  #########
  # Samsung Android Devices
  # @ref: http://www.samsung.com/us/mobile/cell-phones/all-products
  #########
  - regex: 'samsung|ek-|gt-|sch-|scl|sgh-|shv-|shw-|sm-|sph-|yp-'
    regex_flag: 'i'
    group:
      - regex: '^(?:SAMSUNG |Samsung )([^\/]*)\/[^ ]*'
        brand: 'Samsung'
      - regex: '(?:SAMSUNG[ _\-] *|[Ss]amsung )+([^;/]+)'
        brand: 'Samsung'
      - regex: '^(?:SAMSUNG-)?(GT\-[BINPS]\d{4}[^\/]*)'
        brand: 'Samsung'
      - regex: '^(?:SAMSUNG-)([A-Za-z0-9\-]+).*'
        brand: 'Samsung'
      - regex: '^((?:SCH|SGH|SHV|SHW|SPH|SC|SM)\-[A-Za-z0-9 ]+)(/?[^ ]*)?'
        brand: 'Samsung'
      - regex: '^(EK-GC\d{3}|YP\-G[^;/]+)(/?[^ ]*)?'
        brand: 'Samsung'

  #########
  # Acer
  # @ref: http://us.acer.com/ac/en/US/content/group/tablets
  #########
  - regex: 'acer'
    regex_flag: 'i'
    group:
      - regex: '^Acer(?:_AV[^_]+_|\/acer; |[ _-])?([^;\)]+)'
        regex_flag: 'i'
        brand: 'Acer'

  #########
  # Advan
  # @ref: http://www.advandigital.com/
  #########
  - regex: '^ADVAN[ _]([^\s\)_]+)'
    brand: 'Advan'

  #########
  # Ainol
  # @ref: http://www.ainol.com/plugin.php?identifier=ainol&module=product
  #########
  - regex: 'ainol|novo'
    regex_flag: 'i'
    group:
      - regex: '^Ainol[ _]([^;/\(]+)'
        brand: 'Ainol'
      - regex: '^(Novo ?\d[^;/\(]+)'
        regex_flag: 'i'
        brand: 'Ainol'

  #########
  # Airis
  # @ref: http://airis.es/Tienda/Default.aspx?idG=001
  #########
  - regex: 'airis|onepad'
    regex_flag: 'i'
    group:
      - regex: '^(OnePAD|ONEPAD) ?(.*)'
        brand: 'Airis'
        model: '$1 $2'
        type: 'tablet'
      - regex: '^(?:AIRIS[ _\-]?)+(.+)'
        regex_flag: 'i'
        brand: 'Airis'

  #########
  # Airpad
  # @ref: ??
  #########
  - regex: '^Airpad[ -](.+)'
    brand: 'Airpad'

  #########
  # Alcatel - TCT
  # @ref: http://www.alcatelonetouch.com/global-en/products/smartphones.html
  #########
  - regex: 'alcatel|one.?touch|\bot\b|\btcl'
    regex_flag: 'i'
    group:
      - regex: '^(?:alcatel[ _])?(?:(?:one[ _\-]?touch[ _\-])|ot[ _\-])(.+)'
        regex_flag: 'i'
        brand: 'Alcatel'
        model: 'One Touch $1'
      - regex: '\bAlcatel[ _](.+)'
        regex_flag: 'i'
        brand: 'Alcatel'
      - regex: '\bTCL[ _](.+)'
        regex_flag: 'i'
        brand: 'TCL'
      # FirefoxOS
      - regex: 'SVN[: ]\d+.*$'
        replace: ''
      - regex: '(?:ALCATEL)?OneTouch(.*)'
        brand: 'Alcatel'
        model: 'One Touch $1'

  #########
  # Allfine
  # @ref: http://www.myallfine.com/Products.asp
  #########
  - regex: '^((?:FINE|Fine)\d[^;/]+)'
    brand: 'Allfine'

  #########
  # Allview
  # @ref: http://www.allview.ro/produse/droseries/lista-tablete-pc/
  #########
  - regex: '^(?:ALLVIEW|Allview)[ _]?(.*)'
    brand: 'Allview'

  #########
  # Allwinner
  # @ref: http://www.allwinner.com/
  # @models: A31 (13.3"),A20,A10,
  #########
  - regex: '^(?:Allwinner)[ _\-]?(.+)'
    brand: 'Allwinner'

  #########
  # Amaway
  # @ref: http://www.amaway.cn/
  #########

  #########
  # Amoi
  # @ref: http://www.amoi.com/en/prd/prd_index.jspx
  #########
  - regex: '^(?:AMOI|Amoi)[ _]([^;/]+)'
    brand: 'Amoi'
  - regex: '(A\d{3}W)'
    brand: 'Amoi'

  #########
  # Aoc
  # @ref: http://latin.aoc.com/media_tablet
  #########

  #########
  # Aoson
  # @ref: http://www.luckystar.com.cn/en/mid.aspx?page=1
  # @ref: http://www.luckystar.com.cn/en/mobiletel.aspx?page=1
  # @note: brand owned by luckystar
  #########

  #########
  # Apanda
  # @ref: http://www.apanda.com.cn/
  #########
  - regex: '^[Aa]panda[ _\-](.+)'
    brand: 'Apanda'

  #########
  # Archos
  # @ref: http://www.archos.com/de/products/tablets.html
  # @ref: http://www.archos.com/de/products/smartphones/index.html
  #########
  - regex: '^(?:ARCHOS|Archos)[ _]?(.+)'
    brand: 'Archos'

  #########
  # A-rival
  # @ref: http://www.a-rival.de/de/
  #########
  - regex: '^((?:BioniQ|PAD-FMD).*)'
    brand: 'Arival'

  #########
  # Arnova
  # @ref: http://arnovatech.com/
  #########
  - regex: '^(AN\d.+|ARCHM\d+)'
    brand: 'Arnova'
  - regex: '^(?:ARNOVA|Arnova) ?(.+)'
    brand: 'Arnova'

  #########
  # Assistant
  # @ref: http://www.assistant.ua
  #########
  - regex: '^(?:ASSISTANT )?(AP-?\d.*)'
    brand: 'Assistant'

  #########
  # Asus
  # @ref: http://www.asus.com/uk/Tablets_Mobile/
  #########
  - regex: '^(?:asus[ -])?ASUS(?: - |[ _-]*)(.+)'
    regex_flag: 'i'
    brand: 'Asus'

  #########
  # Avvio
  # @ref: http://www.avviomobile.com
  #########
  - regex: 'Avvio'
    regex_flag: 'i'
    group:
      - regex: '^Avvio[ _\-]?(pad.*)'
        regex_flag: 'i'
        brand: 'Avvio'
        type: 'tablet'
      - regex: '^Avvio[ _\-]?(.+)'
        regex_flag: 'i'
        brand: 'Avvio'
        type: 'smartphone'

  #########
  # Garmin-Asus
  #########
  - regex: '^((Garminfone)|^Garmin-Asus (.+))'
    brand: 'Garmin-Asus'
    model: '$2$3'

  #########
  # Attab
  # @ref: http://www.theattab.com/
  #########
  - regex: '^(@TAB-.+)'
    brand: 'Attab'

  #########
  # Audiosonic
  # @ref: ??
  # @note: Take care with Docomo T-01 Toshiba
  #########

  #########
  # Avus
  # @ref: http://www.avus.cc/
  #########
  - regex: '^AVUS (.+)'
    brand: 'Avus'

  #########
  # Axioo
  # @ref: http://www.axiooworld.com/ww/index.php
  #########
  - regex: '^(?:Axioo[ _\-]?(.+)|(pico(?:pad|phone))[ _\-]([^(]+))'
    regex_flag: 'i'
    brand: 'Axioo'
    model: '$1$2 $3'

  #########
  # Azumi
  # @ref: http://azumi-mobile.com/
  #########
  - regex: '^(Azumi)[ _](.+)'
    regex_flag: 'i'
    brand: 'Azumi'
    model: '$2'

  #########
  # Bak
  # @ref: http://www.bakinternational.com/produtos.php?cat=80
  #########
  - regex: '^(IBAK\-.*)'
    regex_flag: 'i'
    brand: 'Bak'

  #########
  # Bangho
  # @ref: http://www.bangho.com.ar
  #########
  - regex: '^((?:Aero|AERO) ?[^\s]*)'
    brand: 'Bangho'

  #########
  # Bedove
  # @ref: http://www.bedove.com/product.html
  # @models: HY6501|HY5001|X12|X21|I5
  #########

  #########
  # Benss
  # @ref: http://www.benss.net/
  #########
  - regex: '^(JC-.*)'
    brand: 'Benss'

  #########
  # Blackberry
  # @ref: http://uk.blackberry.com/
  # @note: Android Apps seams to be used here
  #########
  - regex: 'BB (.+)'
    brand: 'Blackberry'

  #########
  # Blackbird
  # @ref: http://iblackbird.co.kr
  #########
  - regex: '^BlackBird[ _](.*)'
    brand: 'BlackBird'

  #########
  # Blaupunkt
  # @ref: http://www.blaupunkt.com
  #########
  # Endeavour
  - regex: '^(Endeavour.+)'
    brand: 'Blaupunkt'

  #########
  # Blu
  # @ref: http://bluproducts.com
  #########
  - regex: '^(?:BLU|Blu)[ _\-](.+)'
    brand: 'Blu'

  #########
  # Blusens
  # @ref: http://www.blusens.com/es/?sg=1&sv=al&roc=1
  #########
  # tablet
  - regex: '^(TOUCH\d.+)'
    brand: 'Blusens'

  #########
  # Bmobile
  # @ref: http://bmobile.eu.com/?categoria=smartphones-2
  # @note: Might collide with Maxx as AX is used also there.
  #########
  # smartphone
  - regex: '^Bmobile[ _]+(.+)'
    brand: 'Bmobile'
    type: 'smartphone'

  #########
  # bq
  # @ref: http://bqreaders.com
  #########
  - regex: '[Bb]q|Aquaris|Maxwell'
    group:
    - regex: '^(?:[Bb]q)? ?(Aquaris.*)'
      brand: 'bq'
      type: 'smartphone'
    - regex: '^[Bb]q (.+)'
      brand: 'bq'
      type: 'tablet'
    - regex: '(Maxwell .+)'
      brand: 'bq'
      type: 'tablet'

  #########
  # Braun Phototechnik
  # @ref: http://www.braun-phototechnik.de/en/products/list/~pcat.250/Tablet-PC.html
  #########
  - regex: '^((?:B-Tab|B-TAB) ?\d.+)'
    brand: 'Braun'

  #########
  # Broncho
  # @ref: http://www.broncho.cn/
  #########
  - regex: '^Broncho (.+)'
    brand: '$1'

  #########
  # Brondi
  # @ref: https://www.brondi.it/smartphone.html
  #########

  #########
  # Captiva
  # @ref: http://www.captiva-power.de
  #########
  - regex: '^CAPTIVA (.+)'
    brand: 'Captiva'

  #########
  # Casio
  # @ref: http://www.casiogzone.com/
  #########

  #########
  # Cat
  # @ref: http://www.cat-sound.com
  #########
  - regex: '^(?:Cat|CAT) (.+)'
    brand: 'Cat'

  #########
  # Celkon
  # @ref: http://www.celkonmobiles.com/?_a=products
  #########
  - regex: 'Celkon'
    regex_flag: 'i'
    group:
      - regex: '^(?:Celkon)+[ _\*]?([^;/\)]+)'
        regex_flag: 'i'
        brand: 'Celkon'

  #########
  # ChangJia
  # @ref: http://www.cjshowroom.com/eproducts.aspx?classcode=004001001
  # @brief: China manufacturer makes tablets for different small brands
  #         (eg. http://www.zeepad.net/index.html)
  #########
  - regex: '^(TPC[0-9]{4,5})'
    brand: 'ChangJia'

  #########
  # Cloudfone
  # @ref: http://www.cloudfonemobile.com/
  #########
  - regex: 'Cloudfone|CloudPad|Excite|ICE'
    group:
      - regex: '^(?:Cloudfone[ _])?((?:Excite|ICE))[ _]?(\d.+)'
        brand: 'Cloudfone'
        model: 'Cloudfone $1 $2'
      - regex: '^((?:Cloudfone|CloudPad).+)'
        brand: 'Cloudfone'

  #########
  # Cmx
  # @ref: http://cmx.at/de/
  #########
  - regex: '^((?:Aquila|Clanga|Rapax).+)'
    regex_flag: 'i'
    brand: 'Cmx'

  #########
  # CobyKyros
  # @ref: http://cobykyros.com
  # @note: Be careful with MID\d{3} from MpMan or Manta
  #########
  - regex: '^((?:CFW-|Kyros).+)'
    brand: 'CobyKyros'

  #########
  # Coolpad
  # @ref: ??
  #########
  - regex: '^(?:YL-|[Cc]oolpad-)?Cool[Pp]ad[ _]?((?:(?!_CMCC_TD).)+)'
    brand: 'Coolpad'

  #########
  # Cube
  # @ref: http://www.cube-tablet.com/buy-products.html
  #########
  - regex: '^CUBE[ _]((?:(?!--).)*)'
    regex_flag: 'i'
    brand: 'Cube'
    type: 'tablet'

  #########
  # Cubot
  # @ref: http://www.cubotmall.com/
  #########
  - regex: '^(?:CUBOT[ _])+(.+)'
    regex_flag: 'i'
    brand: 'Cubot'

  #########
  # Danew
  # @ref: http://www.danew.com/produits-tablette.php
  #########
  - regex: '^(Dslide.+)'
    brand: 'Danew'
    type: 'tablet'

  #########
  # Dell
  # @ref: http://www.dell.com
  # @ref: http://www.softbank.jp/mobile/support/product/101dl/
  # @ref: http://www.softbank.jp/mobile/support/product/001dl/
  # @ref: http://developer.emnet.ne.jp/android.html
  # @ref: http://www.dell.com/in/p/mobile-xcd28/pd
  # @ref: http://www.dell.com/in/p/mobile-xcd35/pd
  #########
  - regex: '^(?:Dell|DELL)[ _](.+)'
    brand: 'Dell'

  #########
  # Denver
  # @ref: http://www.denver-electronics.com/tablets1/
  #########
  - regex: '^(?:PO#\d{4} |unknown )?(TA[CDQ]-\d+(?:(?! ?PO).)*)'
    brand: 'Denver'
    type: 'tablet'

  #########
  # Dex
  # @ref: http://dex.ua/
  #########
  - regex: '^(iP[789]\d{2}(?:-3G)?|IP10\d{2}(?:-8GB)?)'
    brand: 'Dex'

  #########
  # DNS AirTab
  # @ref: http://www.dns-shop.ru/
  #########
  - regex: '^(AirTab)[ _\-](.+)'
    brand: 'DNS'
    model: '$1 $2'

  #########
  # Docomo (Operator Branded Device)
  # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
  #########

  #########
  # Doogee
  # @ref: http://www.doogeemobile.com/
  #########
  - regex: '^(?:DOOGEE[ -]([^;/]+)|([^;/]+[ -]DG\d{3,4}[A-Z]?)|(DG800))'
    brand: 'Doogee'
    model: '$1$2$3'

  #########
  # Doro
  # @ref: http://doro.com
  #########
  - regex: '^Doro (.*)'
    brand: 'Doro'

  #########
  # DOOV
  # @ref: http://www.doov.com.cn/
  #########
  - regex: '^DOOV[ _](.+)'
    brand: 'DOOV'

  #########
  # Elephone
  # @ref: http://www.elephone.hk/
  #########
  - regex: '^Elephone[ -]?(.+)'
    brand: 'Elephone'

  #########
  # Enot
  # @ref: http://www.enot.ua/
  #########
  - regex: '^(?:Enot|ENOT)[ -]?(.+)'
    brand: 'Enot'

  #########
  # Evercoss
  # @ref: http://evercoss.com/android/
  #########
  - regex: '^(?:CROSS|Cross)+[ _\-]([^;]+)'
    brand: 'Evercoss'
    model: 'Cross $1'
  - regex: '^(?:EVERCOSS)+[ _\-]([^;]+)'
    brand: 'Evercoss'
    model: '$1'

  #########
  # Explay
  # @ref: http://explay.ru/
  #########
  - regex: 'Explay|Informer'
    group:
      - regex: '^Explay[_ ](.*)'
        brand: 'Explay'
      - regex: '^(Informer)[ \-]([^;/]+)'
        brand: 'Explay'
        model: '$1 $2'

  #########
  # Fairphone
  # @ref: https://www.fairphone.com/
  #########
  - regex: '^(FP\d[A-Z]*)$'
    brand: 'Fairphone'

  #########
  # Fly
  # @ref: http://www.fly-phone.com/
  #########
  - regex: '^(IQ|Fly|FLY)'
    group:
      - regex: '^(?:Fly|FLY)[ _](.*)'
        brand: 'Fly'
      - regex: '^(IQ\d{3,}.*|FLY)'
        brand: 'Fly'

  #########
  # Fujitsu
  # @ref: http://www.fujitsu.com/global/
  #########

  #########
  # Galapad
  # @ref: http://www.galapad.net/product.html
  #########

  #########
  # Geeksphone
  # @ref: http://www.geeksphone.com/
  #########
  - regex: '^(Geeksphone) (.+)'
    brand: '$1'
    model: '$2'

  #########
  # Gfive
  # @ref: http://www.gfivemobile.com/en
  #########
  #- regex: '; *(G\'?FIVE) ([^;/]+) Build' # there is a problem with python yaml parser here
  - regex: '^G[^F]?FIVE (.+)'
    brand: 'Gfive'

  #########
  # Gionee
  # @ref: http://www.gionee.com/
  #########
  - regex: 'Gionee|GN'
    regex_flag: 'i'
    group:
      - regex: '^(?:GIO-)?Gionee[ _\-]([^;/]+)'
        regex_flag: 'i'
        brand: 'Gionee'
      - regex: '^(GN\d+[A-Z]?)'
        brand: 'Gionee'

  #########
  # GoClever
  # @ref: http://www.goclever.com
  #########
  - regex: '^GOCLEVER ([^;/]+)'
    brand: 'GoClever'
  - regex: '^(QUANTUM[ _].+)'
    brand: 'GoClever'

  #########
  # Google
  # @ref: http://www.google.de/glass/start/
  #########
  - regex: '^(Glass \d+)'
    brand: 'Google'

  #########
  # Gigabyte
  # @ref: http://gsmart.gigabytecm.com/en/
  #########
  - regex: '^(GSmart)[ -]([^/]+)'
    brand: 'Gigabyte'
    model: '$1 $2'

  #########
  # Gigaset
  # @ref: http://www.gigaset.com/
  #########
  - regex: '^(Gigaset)[ ]([^/]+)'
    brand: '$1'
    model: '$2'

  #########
  # G-Tide
  # @ref: http://www.g-tidemobile.com
  #########
  - regex: '^G-TiDE[ _]([^/]+)'
    regex_flag: i
    brand: 'G-Tide'

  #########
  # Freescale development boards
  # @ref: http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=IMX53QSB
  #########

  #########
  # Haier
  # @ref: http://www.haier.com/
  # @ref: http://www.haier.com/de/produkte/tablet/
  #########
  - regex: '^Haier[ _\-]([^/;]+)'
    brand: 'Haier'

  #########
  # Haipad
  # @ref: http://www.haipad.net/
  # @models: V7P|M7SM7S|M9XM9X|M7XM7X|M9|M8|M7-M|M1002|M7|M701
  #########

  #########
  # Hannspree
  # @ref: http://www.hannspree.eu/
  #########
  - regex: '^(SN\d+[A-Z]?T[^;\(]*|Hanns.*)'
    brand: 'HANNspree'

  #########
  # HCLme
  # @ref: http://www.hclmetablet.com/india/
  #########
  - regex: '^HCL (?:ME Tablet )?([^;\)]+)'
    brand: 'HCLme'

  #########
  # Hena
  # @ref: http://www.henadigital.com/en/product/index.asp?id=6
  #########

  #########
  # Hisense
  # @ref: http://www.hisense.com/
  #########
  - regex: '^(EG\d{2,}|HS-[A-Z][^;/]+|MIRA[^;/]+)'
    brand: 'Hisense'

  #########
  # hitech
  # @ref: http://www.hitech-mobiles.com/
  #########
  - regex: '^(?:AMAZE[ _](S\d+)|(S\d+)[ _]AMAZE)'
    family: 'AMAZE $1$2'
    brand: 'hitech'
    model: 'AMAZE $1$2'

  #########
  # HP
  # @ref: http://www.hp.com/
  #########
  - regex: '^(PlayBook|Slate \d+(?: Pro)?)'
    brand: 'HP'
  - regex: '^HP ([^/]+)'
    brand: 'HP'

  #########
  # HTC
  # @ref: http://www.htc.com/www/products/
  # @ref: http://en.wikipedia.org/wiki/List_of_HTC_phones
  #########
  # Android HTC with Version Number matcher
  # ; HTC_0P3Z11/1.12.161.3 Build
  # ;HTC_A3335 V2.38.841.1 Build
  - regex: '^HTC[ _-]([^,]+)(?: MIUI| MFR\=| Firmware version|(?:[/\\]1\.0 | V|/| +)\d+\.\d[\d\.]+)'
    brand: 'HTC'
  # general matcher for anything else
  - regex: '^(?:htccn_chs-|HTC[ -])?HTC[ _\-]?(.*)'
    regex_flag: 'i'
    brand: 'HTC'

  #########
  # Hyundai
  # @ref: http://www.hyundaitechnologies.com
  #########
  - regex: '^HYUNDAI (.+)'
    brand: 'Hyundai'

  #########
  # iBall
  # @ref: http://www.iball.co.in/Category/Mobiles/22
  #########
  - regex: '^(?:iBall[ _\-])?(Andi[ _]?\d[^;/]*)'
    regex_flag: 'i'
    brand: 'iBall'
  - regex: '^IBall(?:[ _]([^;/]+)|)'
    regex_flag: 'i'
    brand: 'iBall'

  #########
  # iconBIT
  # @ref: http://www.iconbit.com/catalog/tablets/
  #########
  - regex: '^(NT-\d+[^ ;/]*|Net[Tt]AB [^;/]+|Mercury [A-Z]+|iconBIT)(?: S/N:[^;/]+)?'
    brand: 'iconBIT'

  #########
  # IMO
  # @ref: http://www.ponselimo.com/
  #########
  - regex: '^IMO[ _]([^;/]+)'
    regex_flag: 'i'
    brand: 'IMO'

  #########
  # i-mobile
  # @ref: http://www.i-mobilephone.com/
  #########
  - regex: '^i-?mobile[ _]([^/]+)'
    regex_flag: 'i'
    brand: 'imobile'
  - regex: '^(i-(?:style|note)[^/]*)'
    regex_flag: 'i'
    brand: 'imobile'

  #########
  # Impression
  # @ref: http://impression.ua/planshetnye-kompyutery
  #########
  - regex: '^(ImPAD) ?(\d+(?:.)*)'
    brand: 'Impression'
    model: '$1 $2'

  #########
  # Infinix
  # @ref: http://www.infinixmobility.com/index.html
  #########
  - regex: '^Infinix[ _]([^;/]+)'
    brand: 'Infinix'

  #########
  # InFocus
  # @ref:
  #########
  - regex: '^InFocus[ _]([^;/]+)'
    brand: 'InFocus'

  #########
  # Intenso
  # @ref: http://www.intenso.de
  # @models: 7":TAB 714,TAB 724;8":TAB 814,TAB 824;10":TAB 1004
  #########

  #########
  # Intex
  # @ref: http://intexmobile.in/index.aspx
  # @note: Zync also offers a "Cloud Z5" device
  #########
  # smartphones
  - regex: '^(?:Intex[ _])?(AQUA|Aqua|Auqa)[ _\.\-]([^;/]+)'
    brand: 'Intex'
    model: '$1 $2'

  # matches "INTEX CLOUD X1"
  - regex: 'intex|i-?buddy'
    regex_flag: 'i'
    group:
      - regex: '^(?:INTEX|Intex)(?:[_ ]([^\ _;/]+))(?:[_ ]([^\ _;/]+))?'
        brand: 'Intex'
        model: '$1 $2'
      # tablets
      - regex: '^[iI]Buddy[ _]?(Connect)(?:_|\?_| )?([^;/]*)'
        brand: 'Intex'
        model: 'iBuddy $1 $2'
        type: 'tablet'
      - regex: '^I-Buddy[ _]([^;/]+)'
        brand: 'Intex'
        model: 'iBuddy $1'

  #########
  # iOCEAN
  # @ref: http://www.iocean.cc/
  #########
  - regex: '^iOCEAN ([^/]+)'
    regex_flag: 'i'
    brand: 'iOCEAN'

  #########
  # i.onik
  # @ref: http://www.i-onik.de/
  #########
  - regex: '^(TP\d+(?:\.\d+)?\-\d[^;/]+|TU-\d{4}A)'
    brand: 'ionik'
    type: 'tablet'

  #########
  # IRU.ru
  # @ref: http://www.iru.ru/catalog/soho/planetable/
  #########

  #########
  # Ivio
  # @ref: http://www.ivio.com/mobile.php
  # @models: DG80,DG20,DE38,DE88,MD70
  #########
  - regex: '^IVIO[_\-]([^;/]+)'
    brand: 'Ivio'

  #########
  # Jaytech
  # @ref: http://www.jay-tech.de/jaytech/servlet/frontend/
  #########
  - regex: '^(TPC[-_](?:PA|PX)?[\d\.]+[A-Z]?|JAY-TECH)'
    brand: 'Jaytech'

  #########
  # JiaYu
  # @ref: http://www.ejiayu.com/en/Product.html
  #########
  - regex: '^(JY-[^;/]+|G[234]S?)'
    brand: 'JiaYu'

  #########
  # JXD
  # @ref: http://www.jxd.hk/
  #########
  - regex: '^JXD[ _\-]([^;/]+)'
    brand: 'JXD'

  #########
  # Karbonn
  # @ref: http://www.karbonnmobiles.com/products_tablet.php
  #########
  - regex: '^(?:KB-)?Karbonn[ _]?([^;/]+)'
    regex_flag: 'i'
    brand: 'Karbonn'

  #########
  # Kazam
  # @ref: https://www.kazam.mobi/
  #########
  - regex: 'kazam|tornado|trooper'
    regex_flag: 'i'
    group:
      - regex: '^Kazam ([^;/]+)'
        regex_flag: 'i'
        brand: 'Kazam'
      - regex: '^(Tornado \d+|Trooper[^;/]+)'
        regex_flag: 'i'
        brand: 'Kazam'

  #########
  # KDDI (Operator Branded Device)
  # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
  #########

  #########
  # Kiano
  # @ref: http://elegance.kiano.pl/en/
  #########
  - regex: '^Kiano ?([^;/]+)'
    regex_flag: 'i'
    brand: 'Kiano'

  #########
  # Kingcom
  # @ref: http://www.e-kingcom.com
  #########
  - regex: '^((?:JOYPAD|Joypad)[ _][^;/]+)'
    brand: 'Kingcom'

  #########
  # Kobo
  # @ref: https://en.wikipedia.org/wiki/Kobo_Inc.
  # @ref: http://www.kobo.com/devices#tablets
  #########

  #########
  # K-Touch
  # @ref: ??
  #########
  - regex: '^(?:TY-)?K-Touch[ _]([^;/]+)'
    regex_flag: 'i'
    brand: 'K-Touch'

  #########
  # KT Tech
  # @ref: http://www.kttech.co.kr
  #########
  - regex: '^((?:EV|KM)-S\d+[A-Z]?)'
    regex_flag: 'i'
    brand: 'KTtech'

  #########
  # Kyocera
  # @ref: http://www.android.com/devices/?country=all&m=kyocera
  #########
  - regex: '^Kyocera[ -](.*)'
    regex_flag: 'i'
    brand: 'Kyocera'

  #########
  # Landvo
  # @ref: http://www.kimovil.com/en/landvo-smartphones-prices
  #########
  - regex: '^(L\d{3}[A-Z]?)'
    brand: 'Landvo'

  #########
  # Lava
  # @ref: http://www.lavamobiles.com/
  #########
  - regex: '^LAVA[ _]([^;/]+)'
    brand: 'Lava'

  #########
  # Leagoo
  # @ref: http://www.leagoo.cc/cs-mobile.html
  #########
  - regex: '^(Lead [^;/]+)'
    regex_flag: 'i'
    brand: 'Leagoo'

  #########
  # Lemon
  # @ref: http://www.lemonmobiles.com/products.php?type=1
  #########
  - regex: '^Lemon[ _]([^;/]+)_?'
    regex_flag: 'i'
    brand: 'Lemon'

  #########
  # Lenco
  # @ref: http://www.lenco.com/c/tablets/
  #########
  - regex: '^Lenco ([^;/]+)'
    brand: 'Lenco'

  #########
  # Lenovo
  # @ref: http://support.lenovo.com/en_GB/downloads/default.page?#
  #########
  - regex: '^((?:Idea(?:Tab|[Pp]ad)|YOGA|ThinkPad)[ _]?[^;/]+)'
    brand: 'Lenovo'
    type: 'tablet'
  - regex: '\b(?:[Ll]enovo|LENOVO)+[ _\-]?([^,;:/\(]+)'
    family: 'Lenovo $1'
    brand: 'Lenovo'

  #########
  # Lexibook
  # @ref: http://www.lexibook.com/fr
  #########
  # [A-Z]{2} = language version code
  - regex: '^(MFC\d+)[A-Z]{2}([^;,/]*),?'
    brand: 'Lexibook'
    model: '$1$2'

  #########
  # LG
  # @ref: http://www.lg.com/uk/mobile
  #########
  - regex: '^(L-\d+[A-Z]|LGL\d+[A-Z]?)(?:/V\d+)?'
    brand: 'LG'
  - regex: '^LG-(E610|P710)\d{2}[a-z]'
    brand: 'LG'
  - regex: '^(?:LG[ \-]|LG)([^;/]+)[;/]?'
    brand: 'LG'
  - regex: '^LG-([^;/]+)/ Mozilla/.*; Android'
    brand: 'LG'

  #########
  # Malata
  # @ref: http://www.malata.com/en/products.aspx?classid=680
  #########
  - regex: '^((?:SMB|smb)[^;/]+)'
    brand: 'Malata'
  - regex: '^(?:Malata|MALATA) ([^;/]+)'
    brand: 'Malata'

  #########
  # Manta
  # @ref: http://www.manta.com.pl/en
  #########

  #########
  # Match
  # @ref: http://www.match.net.cn/products.asp
  #########

  #########
  # Maxx
  # @ref: http://www.maxxmobile.in/
  # @models: Maxx MSD7-Play, Maxx MX245+ Trance, Maxx AX8 Race, Maxx MSD7 3G- AX50, Maxx Genx Droid 7 - AX40, Maxx AX5 Duo,
  #   Maxx AX3 Duo, Maxx AX3, Maxx AX8 Note II (Note 2), Maxx AX8 Note I, Maxx AX8, Maxx AX5 Plus, Maxx MSD7 Smarty,
  #   Maxx AX9Z Race,
  #   Maxx MT150, Maxx MQ601, Maxx M2020, Maxx Sleek MX463neo, Maxx MX525, Maxx MX192-Tune, Maxx Genx Droid 7 AX353,
  # @note: Need more User-Agents!!!
  #########

  #########
  # Mediacom
  # @ref: http://www.mediacomeurope.it/
  #########
  - regex: 'M-PP|M-MP|PhonePad|SmartPad'
    group:
      - regex: '^(M-PP[^;/]+|PhonePad ?\d{2,}[^;/]+)'
        brand: 'Mediacom'
      - regex: '^(M-MP[^;/]+|SmartPad ?\d{2,}[^;/]+)'
        brand: 'Mediacom'

  #########
  # Medion
  # @ref: http://www.medion.com/en/
  #########
  - regex: 'lifetab|medion'
    regex_flag: 'i'
    group:
      - regex: '^(?:MD_)?LIFETAB[ _]([^;/]+)'
        regex_flag: 'i'
        brand: 'Medion'
        model: 'Lifetab $1'
      - regex: '^MEDION ([^;/]+)'
        regex_flag: 'i'
        brand: 'Medion'

  #########
  # Meizu
  # @ref: http://www.meizu.com
  #########
  - regex: '^(?:meizu_|MEIZU )([;\)/]+)'
    brand: 'Meizu'

  #########
  # Micromax
  # @ref: http://www.micromaxinfo.com
  #########
  - regex: 'micromax|p\d{3}'
    regex_flag: 'i'
    group:
      - regex: '\b(?:Micromax[ _\-]?)+(P[A-Za-z0-9]+)'
        regex_flag: 'i'
        brand: 'Micromax'
        type: 'tablet'
      - regex: '\b(?:Micromax[ _\-]?)+([A-Za-z0-9]+)'
        regex_flag: 'i'
        brand: 'Micromax'
        type: 'smartphone'
      - regex: '^(P\d{3})(?:\(Funbook\))?'
        regex_flag: 'i'
        brand: 'Micromax'
        type: 'tablet'

  #########
  # Microsoft
  # @ref: http://www.microsoft.com
  #########
  - regex: '^Microsoft (RM-\d+|Lumia.+)'
    brand: 'Microsoft'

  #########
  # Mito
  # @ref: http://new.mitomobile.com/
  #########
  - regex: '^MITO[ _\-]?([^;/]+)'
    regex_flag: 'i'
    brand: 'Mito'

  #########
  # Mobistel
  # @ref: http://www.mobistel.com/
  #########
  - regex: '^(Cynus)[ _]?(F\d|T\d|[;/\)]+)'
    regex_flag: 'i'
    brand: 'Mobistel'
    model: '$1 $2'

  #########
  # Mobiwire
  # @ref: http://mobiwire.com/
  #########
  - regex: '^(Auriga[^;]*)'
    brand: 'Mobiwire'

  #########
  # Modecom
  # @ref: http://www.modecom.eu/tablets/portal/
  #########
  - regex: 'Modecom|FreeTab'
    regex_flag: 'i'
    group:
      - regex: '^(?:MODECOM )?(FreeTab) ?([^;/]+)'
        regex_flag: 'i'
        brand: 'Modecom'
        model: '$1 $2'
      - regex: '^MODECOM ([^;/]+)'
        regex_flag: 'i'
        brand: 'Modecom'

  #########
  # Motorola
  # @ref: http://www.motorola.com/us/shop-all-mobile-phones/
  #########
  - regex: 'mot[o-]'
    regex_flag: 'i'
    group:
      - regex: '^(?:Motorola MOT-|Motorola[ _\-]|MOT-Moto|MOTO?[ _\-]?)([^;/]+)'
        regex_flag: 'i'
        brand: 'Motorola'
      - regex: '^(?:Moto[_ ]?|MOT\-)([^;/]+)'
        brand: 'Motorola'

  #########
  # MpMan
  # @ref: http://www.mpmaneurope.com
  #########
  - regex: '^((?:MP[DQ]C|MPG\d{1,4}|MP\d{3,4})[^;/]*)'
    brand: 'Mpman'

  #########
  # MSI
  # @ref: http://www.msi.com/product/windpad/
  #########
  - regex: '^(?:MSI[ _])([^;/]+)'
    regex_flag: 'i'
    brand: 'Msi'

  #########
  # Multilaser
  # http://www.multilaser.com.br/listagem_produtos.php?cat=5
  #########
  - regex: '^Multilaser[ _]([^;/]+)'
    brand: 'Multilaser'

  #########
  # MyPhone
  # @ref: http://myphone.com.ph/
  #########
  - regex: '^(My)[_]?(Pad)[ _]([^;/]+)'
    brand: 'MyPhone'
    model: '$1$2 $3'
    type: 'tablet'
  - regex: '^My\|?Phone[ _]([^;/]+)'
    regex_flag: 'i'
    brand: 'MyPhone'
    type: 'smartphone'

  #########
  # Mytab
  # @ref: http://www.mytab.eu/en/category/mytab-products/
  #########
  - regex: '^(my(?:Tab|TAB)[^;/]*)'
    brand: 'Mytab'

  #########
  # Mysaga
  # @ref: http://www.sagaphones.com
  #########
  - regex: '^(?:MY ?SAGA|MySAGA)[ -]([^;/]+)'
    brand: 'Mysaga'

  #########
  # Nabi
  # @ref: https://www.nabitablet.com
  #########
  - regex: '^NABI2?-([^;/]+)'
    brand: 'Nabi'

  #########
  # Nec Medias
  # @ref: http://www.n-keitai.com/
  #########
  - regex: '^NEC-(.+)'
    brand: 'NEC'

  #########
  # Nextbook
  # @ref: http://nextbookusa.com
  #########
  - regex: '^(NXM\d+[A-z0-9_]*|Next\d[A-z0-9_ \-]*|NEXT\d[A-z0-9_ \-]*|Nextbook [A-z0-9_ ]*)'
    brand: 'Nextbook'

  #########
  # Neken
  # @ref: http://www.neken.cn/
  #########
  - regex: '^neken ([^;/]*)'
    brand: 'Neken'

  #########
  # Newman
  # @ref: ?
  #########
  - regex: '^Newman ?([^;/]*)'
    regex_flag: 'i'
    brand: 'Newman'

  #########
  # NGM Mobile
  # @ref: http://www.ngm-mobile.com/
  #########
  - regex: '^NGM[ _](.+)'
    family: 'NGM $1'
    brand: 'NGM'

  #########
  # Nikon
  # @ref: http://imaging.nikon.com/lineup/coolpix/s/s800c/
  #########

  #########
  # Nokia
  # @ref: http://www.nokia.com
  #########
  - regex: '^Nokia (RM-\d+)'
    regex_flag: 'i'
    brand: 'Nokia'
  - regex: '^(?:Nokia[ _\-]*)+([^;/]*)'
    regex_flag: 'i'
    brand: 'Nokia'

  #########
  # Nook
  # @ref:
  # TODO nook browser/1.0
  #########
  - regex: '^(?:Nook ?|Barnes & Noble Nook |BN )([^;/]+)'
    brand: 'Nook'
  - regex: '^(?:NOOK )?(BN[TR]V\d+A?)'
    brand: 'Nook'

  #########
  # NYX
  # @ref: http://www.nyxmobilemexico.com/
  #########
  - regex: '^(NYX)_([^;/_]+)(?:_([^;/_]+))?'
    brand: 'NYX'
    model: '$2 $3'

  #########
  # Olivetti
  # @ref: http://www.olivetti.de/EN/Page/t02/view_html?idp=348
  #########
  - regex: '^(OliPad[^;/]+)'
    brand: 'Olivetti'

  #########
  # Omega
  # @ref: http://omega-technology.eu/en/produkty/346/tablets
  # @note: MID tablets might get matched by CobyKyros first
  # @models: (T107|MID(?:700[2-5]|7031|7108|7132|750[02]|8001|8500|9001|971[12])
  #########
  - regex: '^OMEGA[ _\-](MID[^;/]+)'
    brand: 'Omega'

  #########
  # Oneplus
  # @ref: https://oneplus.net/de
  #########

  #########
  # OpenPeak
  # @ref: https://support.google.com/googleplay/answer/1727131?hl=en
  #########
  - regex: '^((?:CIUS|cius)[^;/]*)'
    brand: 'Openpeak'

  #########
  # O+
  #########
  - regex: '^(O\+ .*)'
    brand: 'O+'

  #########
  # Oppo
  # @ref: http://en.oppo.com/products/
  #########
  - regex: '^OPPO ?([^;/]+)'
    brand: 'Oppo'

  #########
  # Odys
  # @ref: http://odys.de
  #########
  - regex: '^(?:Odys\-|ODYS\-|ODYS )([^;/]+)'
    brand: 'Odys'
  # Weltbild - Tablet PC 4 = Cat Phoenix = Odys Tablet PC 4?

  #########
  # Orion
  # @ref: http://www.orion.ua/en/products/computer-products/tablet-pcs.html
  #########
  - regex: '^(TP-\d+)'
    brand: 'Orion'

  #########
  # PackardBell
  # @ref: http://www.packardbell.com/pb/en/AE/content/productgroup/tablets
  #########

  #########
  # Panasonic
  # @ref: http://panasonic.jp/mobile/
  # @models: T11, T21, T31, P11, P51, Eluga Power, Eluga DL1
  # @models: (tab) Toughpad FZ-A1, Toughpad JT-B1
  #########
  - regex: '^Panasonic[_ ]([^;/]+)'
    brand: 'Panasonic'

  #########
  # Pantech
  # @href: http://www.pantech.co.kr/en/prod/prodList.do?gbrand=PANTECH
  # @href: http://www.pantech.co.kr/en/prod/prodList.do?gbrand=VEGA
  # @models: ADR8995, ADR910L, ADR930VW, C790, CDM8992, CDM8999, IS06, IS11PT, P2000, P2020, P2030, P4100, P5000, P6010, P6020, P6030, P7000, P7040, P8000, P8010, P9020, P9050, P9060, P9070, P9090, PT001, PT002, PT003, TXT8040, TXT8045, VEGA PTL21
  #########
  - regex: '^(SKY[ _])?(IM\-[AT]\d{3}[^;/]+)'
    brand: 'Pantech'
    model: '$1$2'
  - regex: '^Pantech([^;/]+)'
    brand: 'Pantech'

  #########
  # Papayre
  # @ref: http://grammata.es/
  #########
  - regex: '^papyre[ _\-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Papyre'

  #########
  # Pearl
  # @ref: http://www.pearl.de/c-1540.shtml
  #########

  #########
  # Phicomm
  # @ref: http://www.phicomm.com.cn/
  # @ref: http://www.phicommasia.com/
  #########
  - regex: '^PHICOMM ([^;/]+)'
    brand: 'Phicomm'

  #########
  # Philips
  # @ref: http://www.support.philips.com/support/catalog/products.jsp?_dyncharset=UTF-8&country=&categoryid=MOBILE_PHONES_SMART_SU_CN_CARE&userLanguage=en&navCount=2&groupId=PC_PRODUCTS_AND_PHONES_GR_CN_CARE&catalogType=&navAction=push&userCountry=cn&title=Smartphones&cateId=MOBILE_PHONES_CA_CN_CARE
  # @TODO: Philips Tablets User-Agents missing!
  # @ref: http://www.support.philips.com/support/catalog/products.jsp?_dyncharset=UTF-8&country=&categoryid=ENTERTAINMENT_TABLETS_SU_CN_CARE&userLanguage=en&navCount=0&groupId=&catalogType=&navAction=push&userCountry=cn&title=Entertainment+Tablets&cateId=TABLETS_CA_CN_CARE
  #########
  - regex: '^(?:Philips|PHILIPS)[ _]([^;/]+)'
    family: 'Philips $1'
    brand: 'Philips'

  #########
  # Pipo
  # @ref: http://www.pipo.cn/En/
  #########

  #########
  # Ployer
  # @ref: http://en.ployer.cn/
  #########
  - regex: '^(MOMO[^;/]+)'
    brand: 'Ployer'

  #########
  # Polaroid/ Acho
  # @ref: http://polaroidstore.com/store/start.asp?category_id=382&category_id2=0&order=title&filter1=&filter2=&filter3=&view=all
  #########
  - regex: '^Polaroid[ _]([^;/]*)'
    brand: 'Polaroid'

  #########
  # Pomp
  # @ref: http://pompmobileshop.com/
  #########
  - regex: '^POMP[ _\-]([;/\)]+)'
    family: '$1 $2'
    brand: 'Pomp'
    model: '$2'

  #########
  # Positivo
  # @ref: http://www.positivoinformatica.com.br/www/pessoal/tablet-ypy/
  #########
  - regex: '^(TB[01]\d.*|YPY.*|Ypy.*)'
    brand: 'Positivo'
  - regex: 'Positivo ([^;/]+)'
    brand: 'Positivo'

  #########
  # POV
  # @ref: http://www.pointofview-online.com/default2.php
  # @TODO: Smartphone Models MOB-3515, MOB-5045-B missing
  #########
  - regex: '^(MOB-[^;/]+)'
    family: '$1'
    brand: 'POV'
  - regex: '^POV[ _\-]([^;/]+)'
    family: 'POV $1'
    brand: 'POV'

  #########
  # Prestigio
  # @ref: http://www.prestigio.com/catalogue/MultiPhones
  # @ref: http://www.prestigio.com/catalogue/MultiPads
  #########
  - regex: '^(?:Prestigio |PRESTIGIO[ -])*((?:PAP|PSP|PMP|PMT)\d[^;/]+)'
    brand: 'Prestigio'

  #########
  # Proscan
  # @ref: http://www.proscanvideo.com/products-search.asp?itemClass=TABLET&itemnmbr=
  #########
  - regex: '^(PLT[0-9]{4}.*)'
    brand: 'Proscan'

  #########
  # Qmobilevn
  # @ref: http://qmobile.vn/san-pham.html
  #########
  - regex: '^(Q\-Smart[ _][^;/]+)'
    brand: 'Qmobilevn'
  - regex: '^Q-?[Mm]obile[ _\-](S[^;/]+)'
    brand: 'Qmobilevn'

  #########
  # QMobile
  # @ref: http://www.qmobile.com.pk/
  #########
  - regex: '^Q[Mm]obile[_ ]([^;/\)]+)'
    brand: 'Qmobile'

  #########
  # Ramos
  # @ref: http://www.ramos-tablet.com/
  #########
  - regex: '^Ramos ?([^;/]+)'
    brand: 'Ramos'
    type: 'tablet'

  #########
  # Rockchip
  # @ref: http://www.rock-chips.com/a/cn/product/index.html
  # @note: manufacturer sells chipsets - I assume that these UAs are dev-boards
  #########

  #########
  # Runbo
  # @ref: http://www.runbodirect.co.uk/
  #########
  - regex: '^Runbo([^;/]+)'
    brand: 'Runbo'

  #########
  # Sharp
  # @ref: http://www.sharp-phone.com/en/index.html
  # @ref: http://www.android.com/devices/?country=all&m=sharp
  #########
  - regex: '^(SH\-?\d\d[^;/]+|SBM\d[^;/]+|SH[LTV]\d{2})'
    brand: 'Sharp'
  - regex: '^SHARP[ -]([^;/]+)'
    brand: 'Sharp'

  #########
  # Simvalley
  # @ref: http://www.simvalley-mobile.de/
  #########
  - regex: '^(SPX[_\-]\d[^;/]*)'
    brand: 'Simvalley'
  - regex: '^(SX7[.-].+)'
    brand: 'Simvalley'
  - regex: '^(SP[T]?\-\d[^;/]*)'
    brand: 'Simvalley'

  #########
  # SK Telesys
  # @ref: http://www.sk-w.com/phone/phone_list.jsp
  # @ref: http://www.android.com/devices/?country=all&m=sk-telesys
  #########
  - regex: '^(SK\-.*)'
    brand: 'SKtelesys'

  #########
  # Skytex
  # @ref: http://skytex.com/android
  #########
  - regex: '^((?:SKYTEX|SX)-[^;/]+)'
    brand: 'Skytex'
    type: 'tablet'
  - regex: '^(IMAGINE [^;/]+)'
    brand: 'Skytex'
    type: 'tablet'

  #########
  # SmartQ
  # @ref: http://en.smartdevices.com.cn/Products/
  # @models: Z8, X7, U7H, U7, T30, T20, Ten3, V5-II, T7-3G, SmartQ5, K7, S7, Q8, T19, Ten2, Ten, R10, T7, R7, V5, V7, SmartQ7
  #########
  - regex: '^SmartQ ?([^;/]+)'
    brand: 'SmartQ'

  #########
  # Smartbitt
  # @ref: http://www.smartbitt.com/
  # @missing: SBT Useragents
  #########

  #########
  # Softbank (Operator Branded Devices)
  # @ref: http://www.ipentec.com/document/document.aspx?page=android-useragent
  #########

  #########
  # Trekstor
  # @ref: http://www.trekstor.co.uk/surftabs-en.html
  # @note: Must come before SonyEricsson
  #########
  - regex: '^((?:SurfTab |ST\d{4})(?:(?!Build).)*)'
    brand: 'Trekstor'
  - regex: '^TrekStor[ _-](.*)'
    regex_flag: 'i'
    brand: 'Trekstor'

  #########
  # Smartbook
  # @ref: http://www.smartbook.de/
  #########
  - regex: '^Smartbook[^ ]? ([^;/]+)'
    regex_flag: 'i'
    brand: 'Smartbook'

  #########
  # SonyEricsson
  # @ref: http://www.android.com/devices/?country=all&m=sony-ericssons
  # @TODO: type!
  #########
  # android matchers
  - regex: '^Sony ?Ericsson ?([^;/]+)'
    brand: 'SonyEricsson'

  #########
  # Sony
  # @ref: http://www.sonymobile.co.jp/index.html
  # @ref: http://www.sonymobile.com/global-en/products/phones/
  # @ref: http://www.sony.jp/tablet/
  #########
  - regex: '^Sony ([^;/]+)'
    brand: 'Sony'
  - regex: '^Sony([A-Za-z0-9\-]+)'
    brand: 'Sony'
  - regex: '^(Xperia [^;/]+)'
    brand: 'Sony'
  - regex: '^(SGP\d{3}|SGPT\d{2})'
    brand: 'Sony'

  #########
  # Spice
  # @ref: http://www.spicemobilephones.co.in/
  #########
  - regex: '^((?:CSL_Spice|Spice|SPICE|CSL)[ _\-]?)?([Mm][Ii])([ _\-])?(\d{3}[^;/]*)'
    brand: 'Spice'
    model: 'Mi$4'

  #########
  # Switel
  # @ref: http://www.switelmobile.com
  #########

  #########
  # Symphony
  # @ref: http://symphony-mobile.com/
  #########
  #~ - regex: '(.*)'
    #~ model: '##$1##'
  - regex: '^(?:Symphony[ _])+(.+)'
    brand: 'Symphony'

  #########
  # Tagi
  # @ref: ??
  #########
  - regex: '^TAGI ?(MID) ?([^;/]+)'
    brand: 'Tagi'
    model: '$1$2'

  #########
  # Tecmobile
  # @ref: http://www.tecmobile.com/
  #########

  #########
  # Tecno
  # @ref: www.tecno-mobile.com/‎
  #########
  - regex: '^TECNO[ _]([^;/]+)'
    brand: 'Tecno'

  #########
  # Telechips, Techvision evaluation boards
  # @ref:
  #########
  - regex: '^Android for (Telechips|Techvision) ([^ ]+)'
    regex_flag: 'i'
    brand: '$1'
    model: '$2'

  #########
  # Telstra
  # @ref: http://www.telstra.com.au/home-phone/thub-2/
  # @ref: https://support.google.com/googleplay/answer/1727131?hl=en
  #########

  #########
  # Terra
  # @ref: http://www.wortmann.de/
  #########

  #########
  # Texet
  # @ref: http://www.texet.ru/tablet/
  #########
  - regex: '^(T[BM]-\d{3}[^;/]+)'
    family: '$1'
    brand: 'Texet'

  #########
  # TiPhone
  # @ref: ??
  #########
  - regex: '^TiPhone[ \-]([^;/]+)'
    brand: 'TiPhone'
    type: 'smartphone'

  #########
  # Tolino
  # @ref: http://www.thalia.de/shop/tolino-shine-ereader/show/
  #########
  - regex: '^(tolino [^;/]+)'
    family: '$1'
    brand: 'Tolino'
  - regex: '(TOLINO_BROWSER)'
    family: '$1'
    brand: 'Tolino'
    model: 'Tolino Shine'

  #########
  # Thl
  # @ref: http://en.thl.com.cn/Mobile
  # @ref: http://thlmobilestore.com
  #########
  - regex: '^(?:CJ[ -])?(?:ThL|THL|thl)[ _\-]{1,2}([^;/]+)'
    brand: 'Thl'

  #########
  # Tomtec
  # @ref: http://www.tom-tec.eu/pages/tablets.php
  #########
  - regex: '^(ATP[0-9]{4})'
    brand: 'Tomtec'

  #########
  # Tooky
  # @ref: http://www.tookymobile.com/
  #########
  - regex: '^TOOKY[ _\-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Tooky'

  #########
  # Toshiba
  # @ref: http://www.toshiba.co.jp/
  # @missing: LT170, Thrive 7, TOSHIBA STB10
  #########
  - regex: 'TOSHIBA[ _-](?:MOBILE COMMUNICATIONS LIMITED )?([^ ;]+)'
    brand: 'Toshiba'

  #########
  # Touchmate
  # @ref: http://touchmatepc.com/new/
  #########
  - regex: '^(TM-(?:MID|SM)\d+[^;/]+)'
    brand: 'Touchmate'

  #########
  # Treq
  # @ref: http://www.treq.co.id/product
  #########
  - regex: '^TREQ[ _\-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Treq'

  #########
  # TWM
  # @ref: http://www.taiwanmobile.com
  #########
  - regex: '^(Amazing [^;/]+)'
    brand: 'TWM'

  #########
  # Umeox
  # @ref: http://umeox.com/
  # @models: A936|A603|X-5|X-3
  #########

  #########
  # Umi
  # @ref: http://www.91umi.com/
  #########
  - regex: '^UMI[ _](.+)'
    brand: 'Umi'

  #########
  # Versus
  # @ref: http://versusuk.com/support.html
  #########
  - regex: '^CnM[ \-](.+)'
    regex_flag: 'i'
    brand: 'CnM'
    type: 'tablet'
  - regex: '^(?:VS|Versus)[ \-](.+)'
    regex_flag: 'i'
    brand: 'Versus'
    type: 'tablet'

  #########
  # Vertu
  # @ref: http://www.vertu.com/
  #########
  - regex: '^VERTU ([^;/]+)'
    regex_flag: 'i'
    brand: 'Vertu'

  #########
  # Videocon
  # @ref: http://www.videoconmobiles.com
  #########
  - regex: '^Videocon[ _\-]([^;/]+)'
    brand: 'Videocon'
  - regex: '^(VT\d{2}[A-Za-z]*)'
    brand: 'Videocon'

  #########
  # Viewsonic
  # @ref: http://viewsonic.com
  #########
  - regex: '^((?:ViewPad|ViewPhone|VSD)[^;/]+)'
    brand: 'ViewSonic'
  - regex: '^(?:[A-Z]+-)?Viewsonic[ _-]([^;/]+)'
    regex_flag: 'i'
    brand: 'ViewSonic'

  #########
  # vivo (BBK COMMUNICATION TECHNOLOGY CO.LTD)
  # @ref: http://www.vivo.com.cn/
  #########
  - regex: '^[Vv]ivo[ _]([^;/]+)'
    brand: 'Vivo'


  #########
  # Operator Branded Devices
  # @ref: ??
  #########
  - regex: '^(T-Mobile|Vodafone)[ _-](.*)'
    brand: '$1'
    model: '$2'

  #########
  # Vonino
  # @ref: http://www.vonino.eu/
  # TODO Vonino
  #########

  #########
  # Walton
  # @ref: http://www.waltonbd.com/
  #########
  - regex: '^Walton[ _\-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Walton'

  #########
  # Wiko
  # @ref: http://fr.wikomobile.com/collection.php?s=Smartphones
  #########
  - regex: '^WIKO[ \-](.*)'
    regex_flag: 'i'
    brand: 'Wiko'

  #########
  # WellcoM
  # @ref: ??
  #########
  - regex: '^WellcoM[ _-]([^;/]+)'
    brand: 'Wellcom'

  ##########
  # WeTab
  # @ref: http://wetab.mobi/
  ##########
  - regex: '^(WeTab[^;/]*?)'
    regex_flag: 'i'
    brand: 'WeTab'

  #########
  # Wolfgang
  # @ref: http://wolfgangmobile.com/
  #########
  - regex: '^(AT-AS[^;/]+)'
    brand: 'Wolfgang'

  #########
  # Woxter
  # @ref: http://www.woxter.es/es-es/categories/index
  #########
  - regex: '^(?:Woxter|Wxt)[ _-]([^;/]+)'
    brand: 'Woxter'

  #########
  # Yarvik Zania
  # @ref: http://yarvik.com
  #########

  #########
  # Yifang
  # @note: Needs to be at the very last as manufacturer builds for other brands.
  # @ref: http://www.yifangdigital.com/
  # @models: M1010, M1011, M1007, M1008, M1005, M899, M899LP, M909, M8000,
  #   M8001, M8002, M8003, M849, M815, M816, M819, M805, M878, M780LPW,
  #   M778, M7000, M7000AD, M7000NBD, M7001, M7002, M7002KBD, M777, M767,
  #   M789, M799, M769, M757, M755, M753, M752, M739, M729, M723, M712, M727
  #########

  #########
  # XiaoMi
  # @ref: http://www.xiaomi.com/event/buyphone
  # @ref: http://www.mi.com/en
  #########
  - regex: '; *(MI PAD|MiPad [^;/]+|MI \d[^;/]*|MI-ONE [^;/]+|MI2[ _][^;/]+) (?:Build|MIUI)/'
    family: 'XiaoMi $1'
    brand: 'XiaoMi'
  - regex: '; *(HM [^;/]+) Build/'
    family: 'XiaoMi $1'
    brand: 'XiaoMi'

  #########
  # Xolo
  # @ref: http://www.xolo.in/
  #########
  - regex: '^XOLO[ _-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Xolo'

  #########
  # Xoro
  # @ref: http://www.xoro.de/produkte/
  #########
  - regex: '^(?:XORO|Xoro)[ _-]([^;/]+)'
    brand: 'Xoro'

  #########
  # Xtouch
  # @ref: http://xtouch.pk/
  #########
  - regex: 'Xtouch[ _-]([^;/]+)'
    family: 'Xtouch $1$2'
    brand: 'Xtouch'
    model: '$1'

  #########
  # Yezz
  # @ref:
  #########
  - regex: '\b(?:Andy|yezz(?:[ -]andy)?)[ _-]([^;/]+)'
    regex_flag: 'i'
    brand: 'Yezz'
    model: 'Andy $1'

  #########
  # Zopo
  # @ref: http://www.zopomobiles.com/products.html
  #########
  - regex: '^(?:ZOPO|Zopo|ZP)[ _-]([^;/]+)'
    brand: 'Zopo'

  #########
  # Creative
  # @ref: http://www.ziilabs.com/products/platforms/androidreferencetablets.php
  #########
  - regex: '^(?:ZiiLABS[ _-])?(Zii[^;/]*)'
    brand: 'Creative'

  #########
  # ZTE
  # @ref: http://www.ztedevices.com/
  #########
  - regex: '^(?:ZXY-ZTE|ZTE-[CTU]|ZTE)[ _-]([^;/]+)'
    brand: 'ZTE'
  - regex: '^(SmartTab10)-MSM'
    brand: 'ZTE'
    model: '$1'

  ##########
  # Zync
  # @ref: http://www.zync.in/index.php/our-products/tablet-phablets
  ##########

  ##########
  # Kindle
  # @note: Needs to be after Sony Playstation Vita as this UA contains Silk/3.2
  # @ref: https://developer.amazon.com/appsandservices/solutions/devices/kindle-fire/specifications/01-device-and-feature-specifications
  # @ref: http://amazonsilk.wordpress.com/useful-bits/silk-user-agent/
  ##########
  - regex: '^(?:[a-z]{2}-\d+; *)(KF[A-Z]{1,2}(?:WI|WA))'
    brand: 'Amazon'
  - regex: '^Amazon ([^;/]*)'
    brand: 'Amazon'
  - regex: '^(Kindle [^;/]*)'
    brand: 'Amazon'

  #########
  # Devices from chinese manufacturer(s)
  # @note: identified by x-wap-profile http://218.249.47.94/Xianghe/.*
  #########
  - regex: '^sprd[ _-]([^/]+)'
    brand: 'sprd'
  # @ref: http://eshinechina.en.alibaba.com/
  - regex: '^(H\d{2}00\+?) Build'
    brand: 'Hero'
  - regex: '^(iphone|iPhone5)'
    brand: 'Xianghe'
  - regex: '^([^;/]+(?:v\d{2}_[a-z]{2,4}|_jbla?))[^;/]+'
    brand: 'Xianghe'

  - regex: 'Full (?:Android|AOSP) on (.*)$'
    brand: 'Generic_Android'
