###############
# Device Detector - The Universal Device Detection library for parsing User Agents
#
# @link http://piwik.org
# @license http://www.gnu.org/licenses/lgpl.html LGPL v3 or later
###############

'Tunisie Telecom':
  regex: 'StarTrail TT[);/ ]'
  device: 'smartphone'
  model: 'StarTrail'

# SFR
SFR:
  regex: 'StarShine|StarTrail|STARADDICT|StarText|StarNaute|StarXtrem|StarTab'
  device: 'smartphone'
  models:
    - regex: 'StarXtrem[);/ ]'
      model: 'StarXtrem' # ZTE
    - regex: 'StarTrail ?4[);/ ]'
      model: 'StarTrail 4' # ZTE Blade Q
    - regex: 'StarTrail III[);/ ]'
      model: 'StarTrail 3' # ZTE
    - regex: 'StarTrail II[);/ ]'
      model: 'StarTrail 2' # Huawei Ascend Y200
    - regex: 'StarTrail[);/ ]'
      model: 'StarTrail' # ZTE
    - regex: 'StarShine II[);/ ]'
      model: 'StarShine 2' # ZTE
    - regex: 'StarShine[);/ ]'
      model: 'StarShine' # Huawei U8180
    - regex: 'STARADDICT III[);/ ]'
      model: 'Staraddict 3' # Coolpad 8861U
    - regex: 'STARADDICT II Plus[);/ ]'
      model: 'Staraddict 2 Plus' # ZTE Grand X
    - regex: 'STARADDICT II[);/ ]'
      model: 'Staraddict 2' # Alcatel One Touch 995
    - regex: 'STARADDICT[);/ ]'
      model: 'Staraddict' # ZTE
    - regex: 'StarText II[);/ ]'
      model: 'StarText 2' # ZTE
    - regex: 'StarText[);/ ]'
      model: 'StarText' # ZTE
    - regex: 'StarNaute II[);/ ]'
      model: 'StarNaute 2' # ZTE
    - regex: 'StarNaute[);/ ]'
      model: 'StarNaute' # ZTE Amigo
    - regex: 'StarTab'
      model: 'StarTab'
      device: 'tablet'

    - regex: '((?:StarShine|StarTrail|STARADDICT|StarText|StarNaute|StarXtrem)[^;/]*) Build'
      model: '$1'

# HTC
HTC:
  regex: 'HTC|Sprint (?:APA|ATP)|ADR(?!910L)[a-z0-9]+|NexusHD2|Amaze[ _]4G[);/ ]|(Desire|Sensation|Evo ?3D|IncredibleS|Wildfire)[ _]?([^;/]+) Build|(Amaze[ _]4G|One ?[XELSV\+]+)[);/ ]|SPV E6[05]0|One M8'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'ADR6300'
      model: 'Droid Incredible'
    - regex: 'ADR6400L'
      model: 'ThunderBolt'
    - regex: 'ADR6410LRA'
      model: 'Droid Incredible 3'
    - regex: 'SPV E600'
      model: 'Excalibur'
    - regex: 'SPV E650'
      model: 'Vox'

    - regex: 'NexusHD2' # custom rom for hd2
      model: 'HD2'
    - regex: 'HTC[ _\-]((?:Flyer|P715a).*) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'HTC[ _\-]One[ _\-]max[);/ ]'
      device: 'phablet'
      model: 'One max'
    - regex: 'HTC[ _]([^/;]+) [0-9]+(?:\.[0-9]+)+ Build'
      model: '$1'
    - regex: 'HTC[ _]([^/;]+) Build'
      model: '$1'
    - regex: 'HTC[ _]([a-z0-9]+[ _\-]?(?:[a-z0-9_+\-])*)'
      model: '$1'
    - regex: 'USCCHTC(\d+)'
      model: '$1'
    - regex: 'Sprint (ATP.*) Build'
      device: 'tablet'
      model: '$1 (Sprint)'
    - regex: 'Sprint (APA.*) Build'
      model: '$1 (Sprint)'
    - regex: 'HTC(?:[\-/ ])?([a-z0-9\-_]+)'
      model: '$1'
    - regex: 'HTC;(?: )?([a-z0-9 ]+)'
      model: '$1'
    - regex: '(Desire|Sensation|Evo ?3D|IncredibleS|Wildfire)[ _]?([^;/]+) Build'
      model: '$1 $2'
    - regex: '(Amaze[ _]4G|One ?[XELSV\+]*) Build'
      model: '$1'
    - regex: '(ADR[^;/]+) Build'
      model: '$1'
    - regex: '(ADR[a-z0-9]+)'
      model: '$1'
    - regex: '(One M8)'
      model: '$1'

# NOKIA
Nokia:
  regex: 'Nokia|Lumia|Maemo RX|portalmmm/2\.0 N7|portalmmm/2\.0 NK|nok[0-9]+|Symbian.*\s([a-z0-9]+)$|RX-51 N900'
  device: 'smartphone'
  models:
    - regex: 'RX-51 N900'
      model: 'N900'
      device: 'tablet'
    - regex: 'Nokia(N[0-9]+)'
      model: '$1'
    - regex: 'Nokia-([a-z0-9]+)'
      model: 'N$1'
    - regex: 'NOKIA; ([a-z0-9\- ]+)'
      model: '$1'
    - regex: 'NOKIA[ _]?([a-z0-9\-]+)'
      model: '$1'
    - regex: 'NOKIA/([a-z0-9 ]+)'
      model: '$1'
    - regex: '(Lumia [a-z0-9\-]+ XL)'
      device: 'phablet'
      model: '$1'
    - regex: '(Lumia [a-z0-9\-]+)'
      model: '$1'
    - regex: 'Maemo RX-51 ([a-z0-9]+)'
      model: '$1'
    - regex: 'Maemo RX-34'
      model: 'N800'
    - regex: 'NokiaInternal|Nokia-WAP-Toolkit|Nokia-MIT-Browser|Nokia Mobile|Nokia Browser|Nokia/Series'
      model: ''
    - regex: 'portalmmm/2\.0 (N7[37]|NK[a-z0-9]+)'
      model: '$1'
    - regex: 'nok([0-9]+)'
      model: '$1'
    - regex: 'Symbian.*\s([a-z0-9]+)$'
      device: 'feature phone'
      model: '$1'

# CnM
CnM:
  regex: 'CnM'
  device: 'tablet'
  models:
    - regex: 'CnM[ \-](?:Touchpad|TP)[ \-]([0-9\.]+)'
      model: 'Touchpad $1'

# RIM/BlackBerry
RIM:
  regex: 'BB10;|BlackBerry|rim[0-9]+|PlayBook'
  device: 'smartphone'
  models:
    - regex: 'BB10; ([a-z0-9\- ]+)\)'
      model: 'BlackBerry $1'
    - regex: 'PlayBook.+RIM Tablet OS'
      model: 'BlackBerry Playbook'
      device: 'tablet'
    - regex: 'BlackBerry(?: )?([a-z0-9]+)'
      model: 'BlackBerry $1'
    - regex: 'rim([0-9]+)'
      model: 'BlackBerry $1'
    - regex: 'BlackBerry'
      model: 'BlackBerry'

# PALM
Palm:
  regex: '(?:Pre|Pixi)/(\d+)\.(\d+)|Palm|Treo|Xiino'
  device: 'smartphone'
  models:
    - regex: '((?:Pre|Pixi))/(\d+\.\d+)'
      model: '$1 $2'
    - regex: 'Palm(?:[ \-])?((?!OS|Source)[a-z0-9]+)'
      model: '$1'
    - regex: 'Treo([a-z0-9]+)'
      model: 'Treo $1'
    - regex: 'Tungsten'
      model: 'Tungsten'
    - regex: 'Xiino' # Browser for Palm OS only
      model: ''

# HP
HP:
  regex: 'TouchPad/\d+\.\d+|hp-tablet|HP ?iPAQ|webOS.*P160U|HP Slate|HP [78]|Compaq [7|8]'
  device: 'smartphone'
  models:
    - regex: 'HP ([78][^/;]*) Build'
      model: 'Slate $1'
      device: 'tablet'
    - regex: 'Compaq ([78][^/;]*) Build'
      model: 'Compaq $1'
      device: 'tablet'
    - regex: 'HP Slate ?(.+) Build'
      model: 'Slate $1'
      device: 'tablet'
    - regex: 'HP Slate ?([0-9]+)'
      model: 'Slate $1'
      device: 'tablet'
    - regex: 'TouchPad/(\d+\.\d+)|hp-tablet'
      model: 'TouchPad'
      device: 'tablet'
    - regex: 'HP(?: )?iPAQ(?: )?([a-z0-9]+)'
      model: 'iPAQ $1'
    - regex: 'webOS.*(P160U)'
      model: 'Veer'

# TiPhone
TiPhone:
  regex: 'TiPhone ?([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# Apple
Apple:
  regex: '(?:iTunes-)?AppleTV|(?:Apple-)?(?:iPad|iPhone)|iPh[0-9],[0-9]'
  models:
    # specific smartphone devices
    - regex: '(?:Apple-)?iPh(?:one)?1[C,]1'
      model: 'iPhone'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?1[C,]2'
      model: 'iPhone 3G'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?2[C,]1'
      model: 'iPhone 3GS'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?3[C,][123]'
      model: 'iPhone 4'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?4[C,]1'
      model: 'iPhone 4S'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?5[C,][12]'
      model: 'iPhone 5'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?5[C,][34]'
      model: 'iPhone 5C'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?6[C,][12]'
      model: 'iPhone 5S'
      device: 'smartphone'
    - regex: '(?:Apple-)?iPh(?:one)?7[C,]1'
      model: 'iPhone 6 Plus'
      device: 'phablet'
    - regex: '(?:Apple-)?iPh(?:one)?7[C,]2'
      model: 'iPhone 6'
      device: 'smartphone'

    # specific tablet devices
    - regex: '(?:Apple-)?iPad1[C,]1'
      model: 'iPad'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad2[C,][1234]'
      model: 'iPad 2'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad2[C,][567]'
      model: 'iPad Mini'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad3[C,][123]'
      model: 'iPad 3'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad3[C,][456]'
      model: 'iPad 4'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad4[C,][123]'
      model: 'iPad Air'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad4[C,][456]'
      model: 'iPad Mini 2'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad4[C,][789]'
      model: 'iPad Mini 3'
      device: 'tablet'
    - regex: '(?:Apple-)?iPad5[C,][34]'
      model: 'iPad Air 2'
      device: 'tablet'

    - regex: '(?:iTunes-)?AppleTV'
      model: 'Apple TV'
      device: 'tv'
    - regex: '(?:Apple-)?iPad'
      model: 'iPad'
      device: 'tablet'
    - regex: '(?:Apple-)?iPhone ?(3GS?|4S?|5[CS]?|6(:? Plus)?)?'
      model: 'iPhone $1'
      device: 'smartphone'

# micromax
MicroMax:
  regex: 'MicroMax[ \-\_]?[a-z0-9]+'
  device: 'smartphone'
  models:
    - regex: 'MicroMax(?:[ \-\_])?(P[a-z0-9]+)'
      model: '$1'
      device: 'tablet'
    - regex: 'MicroMax(?:[ \-\_])?([a-z0-9]+)'
      model: '$1'

# 3Q
3Q:
  regex: '(AC0731B|AC1024C|AC7803C|BC9710AM|EL72B|LC0720C|LC0723B|LC0725B|LC0804B|LC0808B|LC0809B|LC0810C|LC0816C|LC0901D|LC1016C|MT0724B|MT0729B|MT0729D|MT0811B|OC1020A|RC0709B|RC0710B|RC0718C|RC0719H|RC0721B|RC0722C|RC0726B|RC0734H|RC0743H|RC0817C|RC1018C|RC1019G|RC1025F|RC1301C|RC7802F|RC9711B|RC9712C|RC9716B|RC9717B|RC9724C|RC9726C|RC9727F|RC9730C|RC9731C|TS0807B|TS1013B|VM0711A|VM1017A|RC0813C|QS9719D|QS9718C|QS9715F|QS1023H|QS0815C|QS0730C|QS0728C|QS0717D|QS0716D|QS0715C|MT7801C)'
  device: 'tablet'
  model: '$1'

# Acer
Acer:
  regex: 'acer|a(?:101|110|200|210|211|500|501|510|511|700|701)[);/ ]|Android.*V3[67]0[);/ ]|Android.*Z1[23456]0 Build|Android.*Z500 Build|A1-830|A1-81[01]|A3-A[12][01]|B1-7[1235][01]|B1-810|B1-A71|E39 Build|S5[12]0 Build|DA[0-9]+HQ?L[);/ ]'
  device: 'smartphone'
  models:
    # smart displays
    - regex: 'DA220HQL[);/ ]'
      model: 'DA220HQL'
      device: 'smart display'
    - regex: 'DA241HL[);/ ]'
      model: 'DA241HL'
      device: 'smart display'
    - regex: '(DA[0-9]+HQ?L)[);/ ]'
      model: '$1'
      device: 'smart display'

    # explicit tablet models
    - regex: 'A1-81[01]'
      model: 'Iconia A'
      device: 'tablet'
    - regex: 'A1-830'
      model: 'Iconia A1'
      device: 'tablet'
    - regex: 'A3-A[12][01]'
      model: 'Iconia A3'
      device: 'tablet'
    - regex: 'B1-7[1235][01]|B1-810|B1-A71'
      model: 'Iconia B1'
      device: 'tablet'

    # explicit smartphone models
    - regex: 'E39 Build'
      model: 'Liquid E700'
    - regex: 'Android.*V360[);/ ]'
      model: 'Liquid E1'
    - regex: 'Android.*V370[);/ ]'
      model: 'Liquid E2'
    - regex: 'S510 Build'
      model: 'Liquid S1'
    - regex: 'S520 Build'
      model: 'Liquid S2'
    - regex: 'Android.*Z1([2345])0 Build'
      model: 'Liquid Z$1'
    - regex: 'Android.*Z160 Build'
      model: 'Liquid Z4'
    - regex: 'Android.*Z500 Build'
      model: 'Liquid Z500'
    - regex: 'Acer; ?([^;\)]+)'
      model: '$1'
    - regex: 'Acer[ _\-]?([^;\)]+) Build'
      model: '$1'
    - regex: 'acer[\-_]([a-z0-9]+)'
      model: '$1'
    - regex: 'a(101|110|200|210|211|500|501|510|511|700|701)[);/ ]'
      model: 'Iconia Tab A$1'
      device: 'tablet'

# Airness
Airness:
  regex: 'AIRNESS-([\w0-9]+)'
  device: 'feature phone'
  model: '$1'

# Alcatel
Alcatel:
  regex: 'Alcatel|Alc[a-z0-9]+|One[ _]?Touch'
  device: 'smartphone'
  models:
    - regex: '(?:Alcatel[ _])?One[ _]?Touch[ _]((?:T[0-9]+|TAB[^/;]+|EVO[78](?:HD)?)) Build'
      device: 'tablet'
      model: 'One Touch $1'
    - regex: '(?:Alcatel[ _])?One[ _]?Touch([^/;]*) Build'
      model: 'One Touch$1'
    - regex: '(?:Alcatel[ _])?One[ _]?Touch([^/;\)]*)\)'
      model: 'One Touch$1'
    - regex: 'Alcatel UP'
      model: ''
    - regex: 'ALCATEL([^/;]+) Build'
      model: '$1'
    - regex: 'ALCATEL[ \-]?([^/;\)]+)'
      model: '$1'
    - regex: 'ALCATEL_([^/;\)]+)'
      model: '$1'
    - regex: 'Alc([a-z0-9]+)'
      model: '$1'

# Allview
Allview:
  regex: 'Allview'
  device: 'smartphone'
  models:
    - regex: 'Allview[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Allview[ _-]([^;/]+)[;/)]'
      model: '$1'

# Amoi
Amoi:
  regex: 'Amoi|A862W'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'A862W'
      model: 'A862W'

    - regex: 'Amoi[\- /]([a-z0-9]+)'
      model: '$1'
    - regex: 'Amoisonic-([a-z0-9]+)'
      model: '$1'

# Ainol
'Ainol':
  regex: 'Numy|novo[0-9]'
  device: 'tablet'
  models:
    - regex: 'Numy[ _]([^;/]+) Build'
      model: 'Numy $1'
    - regex: 'Novo([0-9]+)[ \-]([^;/]+) Build'
      model: 'Novo $1 $2'

# Archos
Archos:
  regex: 'Archos'
  device: 'smartphone'
  models:
    - regex: 'Archos ?5[);/ ]'
      device: 'tablet'
      model: '5'
    - regex: 'Archos ([^/;]*(?:PAD)[^/;]*) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'Archos ((?:[789]|10)[0-9]?[a-z]* ?(?:G9|G10|Helium|Titanium|Cobalt|Platinum|Xenon|Carbon|Neon|XS|IT)[^/;]*) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'Archos ([a-z0-9 ]+) Build'
      model: '$1'
    - regex: 'Archos ([a-z0-9]+)'
      model: '$1'

# Axxion
Axxion:
  regex: 'Axxion ATAB-[0-9]+[);/ ]'
  device: 'tablet'
  models:
    - regex: 'Axxion ATAB-([0-9]+)[);/ ]'
      model: 'ATAB-$1'

# Meu
MEU:
  regex: 'MEU ([a-z0-9]+) Build'
  device: 'smartphone'
  model: '$1'

# Arnova
Arnova:
  regex: 'arnova|ARCHM901|AN7CG2|AN7G2(DTE|I)?|AN7[BCDFH]?G3|A80KSC|AN8G2|AN8[BC]?G3|AN9G2I?|AN9G3|A101[BC]|AN10G2|AN10BG2(DT|I)?|AN10BG3(DT)?|AN10[CD]G3'
  device: 'tablet'
  models:
    # explicit tablet models
    - regex: 'ARCHM901'
      model: 'M901'
    - regex: 'AN7CG2'
      model: '7c G2'
    - regex: 'AN7G2I|AN7G2|AN7G2DTE'
      model: '7 G2'
    - regex: 'AN7G3'
      model: '7 G3'
    - regex: 'AN7BG3'
      model: '7b G3'
    - regex: 'AN7CG3'
      model: '7c G3'
    - regex: 'AN7DG3-CP'
      model: 'Childpad'
    - regex: 'AN7DG3'
      model: '7d G3'
    - regex: 'AN7FG3'
      model: '7f G3'
    - regex: 'AN7HG3'
      model: '7h G3'
    - regex: 'A80KSC'
      model: '8'
    - regex: 'AN8G2'
      model: '8 G2'
    - regex: 'AN8G3'
      model: '8 G3'
    - regex: 'AN8BG3'
      model: '8b G3'
    - regex: 'AN8CG3'
      model: '8c G3'
    - regex: 'AN9G2I'
      model: '9i G2'
    - regex: 'AN9G2'
      model: '9 G2'
    - regex: 'AN9G3'
      model: '9 G3'
    - regex: 'A101B2|A101C|AN10G2'
      model: '10 G2'
    - regex: 'A101B'
      model: '10'
    - regex: 'AN10BG2|AN10BG2DT|AN10BG2I'
      model: '10b G2'
    - regex: 'AN10BG3|AN10BG3DT|AN10BG3-LZ'
      model: '10b G3'
    - regex: 'AN10CG3'
      model: '10c G3'
    - regex: 'AN10DG3'
      model: '10d G3'
    - regex: 'ARNOVA 90G3'
      model: '90 G3'
    - regex: 'ARNOVA 90 G4'
      model: '90 G4'
    - regex: 'ARNOVA 97G4'
      model: '97 G4'
    - regex: 'ARNOVA 101 G4'
      model: '101 G4'

    - regex: 'Arnova ([^/;]*) Build'
      model: '$1'

# ARRIS
ARRIS:
  regex: 'ARRIS'
  device: 'tv'
  models:
    - regex: 'ARRIS[,;] ([^),;/]+)'
      model: '$1'

# Garmin-Asus
Garmin-Asus:
  regex: 'Garmin-Asus|Garminfone'
  device: 'smartphone'
  models:
    - regex: 'Garminfone[ \-_]([^;/]*)Build'
      model: 'Garminfone $1'
    - regex: 'Garmin-Asus[ \-_]([^;/]+)Build'
      model: '$1'
    - regex: 'Garmin-Asus[ \-_]([^;/]+)[\)/]'
      model: '$1'

# Asus
Asus:
  regex: 'Asus|Transformer|TF300T|Slider SL101|PadFone|ME302(?:C|KL)|ME301T|ME371MG|ME17(?:1|2V|3X)|(?:K0[01][0-9a-z]|Z00D)[);/ ]'
  device: 'smartphone'
  models:
    # explicit tablet models
    - regex: 'ME171[);/ ]'
      model: 'Eee Pad MeMO 171'
      device: 'tablet'
    - regex: 'ME172V'
      model: 'MeMO Pad'
      device: 'tablet'
    - regex: 'ME302C[);/ ]'
      model: 'MeMO Pad FHD 10'
      device: 'tablet'
    - regex: 'ME302KL[);/ ]'
      model: 'MeMO Pad FHD 10 LTE'
      device: 'tablet'
    - regex: 'ME301T[);/ ]'
      model: 'MeMO Pad Smart 10'
      device: 'tablet'
    - regex: 'K01[3A][);/ ]'
      model: 'MeMO Pad 7'
      device: 'tablet'
    - regex: 'K01E[);/ ]'
      model: 'MeMO Pad 10 ME103K'
      device: 'tablet'
    - regex: 'K00U|ME173X[);/ ]'
      model: 'MeMO Pad HD 7'
      device: 'tablet'
    - regex: '(?:K011|K00L)[);/ ]'
      model: 'MeMO Pad 8'
      device: 'tablet'
    - regex: 'K014[);/ ]'
      model: 'MeMO Pad 8.9'
      device: 'tablet'
    - regex: 'K00S[);/ ]'
      model: 'MeMO Pad HD 7 Dual SIM'
      device: 'tablet'
    - regex: 'K00F[);/ ]'
      model: 'MeMO Pad 10'
      device: 'tablet'
    - regex: 'K00C[);/ ]'
      model: 'Transformer Pad TF701T'
      device: 'tablet'
    - regex: 'K010[);/ ]'
      model: 'Transformer Pad TF103C'
      device: 'tablet'
    - regex: 'K018[);/ ]'
      model: 'Transformer Pad TF103CG'
      device: 'tablet'
    - regex: 'TF300T[);/ ]'
      model: 'Transformer Pad TF300T'
      device: 'tablet'
    - regex: 'Slider SL101'
      model: 'Eee Pad Slider SL101'
      device: 'tablet'

    # explicit phablet models
    - regex: 'ME371MG[);/ ]'
      model: 'Fonepad'
      device: 'phablet'
    - regex: 'K00G[);/ ]'
      model: 'Fonepad Note 6'
      device: 'phablet'
    - regex: '(?:K012|K00E)[);/ ]'
      model: 'Fonepad 7'
      device: 'phablet'
    - regex: 'K00Z[);/ ]'
      model: 'Fonepad 7 Dual SIM'
      device: 'phablet'
    - regex: 'K016[);/ ]'
      model: 'Fonepad 8'
      device: 'phablet'


    # explicit smartphone models
    - regex: '(?:ASUS_)?Z007'
      model: 'ZenFone C'
    - regex: '(?:ASUS_)?(?:Z00D|Z008D|Z00AD[AB]?)'
      model: 'ZenFone 2'
    - regex: '(?:ASUS_)?T00[IQ]'
      model: 'ZenFone 4'
    - regex: '(?:ASUS_)?T00[JF]'
      model: 'ZenFone 5'
    - regex: '(?:ASUS_)?T00P'
      model: 'ZenFone 5 LTE'
    - regex: '(?:ASUS_)?T00K'
      model: 'ZenFone 5 Lite'
    - regex: '(?:ASUS_)?(?:T00G|Z002)'
      model: 'ZenFone 6'

    # general detections
    - regex: 'Asus(?:-|;)?([a-z0-9]+)'
      model: '$1'
    - regex: '(PadFone(?: [^;/]+)?) Build'
      model: '$1'
    - regex: '(PadFone(?: [a-z0-9]+)?)'
      model: '$1'
    - regex: '(?:Asus|Transformer) ((?:Pad |Prime )?TF[0-9a-z]+)'
      device: 'tablet'
      model: 'Transformer $1'

# Audiovox
Audiovox:
  regex: 'Audiovox|CDM|UTS(?:TARCOM)?\-|audio[a-z0-9\-]+'
  device: 'smartphone'
  models:
    - regex: 'Audiovox[_\-]([a-z0-9\-]+)'
      model: '$1'
    - regex: 'CDM(?:-)?([a-z0-9]+)'
      model: 'CDM-$1'
    - regex: 'UTS(?:TARCOM)?-([a-z0-9\-]+)'
      model: 'CDM-$1'
    - regex: 'audio([a-z0-9\-]+)'
      model: 'CDM-$1'

# Avvio
Avvio:
  regex: 'Avvio[ _]([a-z0-9\-]+)'
  device: 'smartphone'
  models:
    - regex: 'Avvio[ _]PAD'
      model: 'PAD'
      device: 'tablet'
    - regex: 'Avvio[ _]([a-z0-9\-]+)'
      model: '$1'

#Barnes & Noble
'Barnes & Noble':
  regex: 'Nook|BN[TR]V[0-9]+'
  device: 'tablet'
  models:
    - regex: 'Nook([a-z0-9]+)'
      model: 'Nook $1'
    - regex: 'Nook[ _]([^/;]+)[ _]Build'
      model: 'Nook $1'
    - regex: '(BN[TR]V[0-9]+)'
      model: 'Nook $1'

# Blu
Blu:
  regex: 'blu ([^/;]+) Build'
  device: 'smartphone'
  model: '$1'

# Boway
Boway:
  regex: 'BOWAY'
  device: 'smartphone'
  models:
    - regex: 'BOWAY[ _-]([^/;]+)[ _]Build'
      model: '$1'
    - regex: '([^/;]+) Build/BOWAY'
      model: '$1'
    - regex: '.*BOWAY[ _-]([^/;]+)/'
      model: '$1'

# Brondi
Brondi:
  regex: '(?:CENTURION|GLADIATOR| GLORY|LUXURY|SENSUELLE|VICTORY)(?:[ _-]?[2-6])?[);/ ]|Surfing Tab'
  device: 'smartphone'
  models:
    - regex: 'CENTURION(?:[ _-]?([2-6]))?[);/ ]'
      model: 'CENTURION $1'
    - regex: 'GLADIATOR(?:[ _-]?([2-6]))?[);/ ]'
      model: 'GLADIATOR $1'
    - regex: 'GLORY(?:[ _-]?([2-6]))?[);/ ]'
      model: 'GLORY $1'
    - regex: 'LUXURY(?:[ _-]?([2-6]))?[);/ ]'
      model: 'LUXURY $1'
    - regex: 'SENSUELLE(?:[ _-]?([2-6]))?[);/ ]'
      model: 'SENSUELLE $1'
    - regex: 'VICTORY(?:[ _-]?([2-6]))?[);/ ]'
      model: 'VICTORY $1'

    - regex: 'Surfing Tab ([^;/]+) Build'
      model: 'SURFING TAB $1'
      device: 'tablet'
    - regex: 'Surfing Tab ([^;/]+)[);/ ]'
      model: 'SURFING TAB $1'
      device: 'tablet'

# Vivo
Vivo:
  regex: '(?:VIV-|BBG-)?vivo'
  device: 'smartphone'
  models:
    - regex: '(?:VIV-|BBG-)?vivo[ _]([^/;]+) Build'
      model: 'Vivo $1'
    - regex: '(?:VIV-|BBG-)?vivo[ _]([^);/]+)[);/]+'
      model: 'Vivo $1'

# Bird
Bird:
  regex: 'BIRD[\-. _]([^;/]+)'
  device: 'feature phone'
  models:
    - regex: 'BIRD[\-. _]([^;/]+) Build'
      model: '$1'
    - regex: 'BIRD[\-. _]([^;/]+)'
      model: '$1'

# Becker
Becker:
  regex: 'Becker-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Beetel
Beetel:
  regex: 'Beetel ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# BenQ-Siemens
BenQ-Siemens:
  regex: 'BENQ-SIEMENS - ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# BenQ
BenQ:
  regex: 'BENQ(?:[ \-])?([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Bmobile
Bmobile:
  regex: 'Bmobile_([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# bq
bq:
  regex: 'Aquaris|bq [^/;]+ Build'
  device: 'tablet'
  models:
    - regex: '(?:bq )?(Aquaris[^/;]*) Build'
      model: '$1'
      device: 'smartphone'
    - regex: 'bq ([^/;]+) Build'
      model: '$1'

# Bush
Bush:
  regex: 'Bush[ _-]'
  device: 'smartphone'
  models:
    - regex: 'BUSH ([^;/]+)Tablet Build'
      model: '$1Tablet'
      device: 'tablet'
    - regex: 'BUSH ([^;/]+) Build'
      model: '$1'

# Capitel
Capitel:
  regex: 'Capitel-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Captiva
Captiva:
  regex: 'Captiva[ _-]([^;/]+) Build'
  device: 'tablet'
  model: 'Pad $1'

# Casio
Casio:
  regex: '(C811|C7[57]1)(?: 4G)?[);/ ]'
  device: 'smartphone'
  models:
    - regex: 'C751[);/ ]'
      model: "G'zOne Ravine"
    - regex: 'C771[);/ ]'
      model: "G'zOne Commando"
    - regex: 'C811 4G[);/ ]'
      model: "G'zOne Commando 4G LTE"

# Cat
Cat:
  regex: 'Cat ?(tablet|stargate|nova)'
  device: 'tablet'
  models:
    - regex: 'Cat ?(?:tablet)? ?((?:Galactica|Nova|StarGate|PHOENIX)[^/;]*) Build'
      model: '$1'
    - regex: 'Cat ?tablet'
      model: 'Nova'

# Carrefour
Carrefour:
  regex: 'CT(?:10[0123]0|7[12]0|820)(?:W|FR)?[);/ ]'
  device: 'tablet'
  models:
    - regex: 'CT820'
      model: 'Touch Tablet Neo2'
    - regex: 'CT(10[0123]0(?:W|FR)?)'
      model: 'CT$1'
    - regex: 'CT(7[12]0(?:W|FR)?)'
      model: 'CT$1'

# Celkon
Celkon:
  regex: 'Celkon'
  device: 'smartphone'
  models:
    - regex: 'Celkon[ _*](C[78]20)'
      model: '$1'
      device: 'tablet'
    - regex: 'Celkon[ _*](CT[^;/]+) Build'
      model: '$1'
      device: 'tablet'
    - regex: 'Celkon[ _*]([^;/]+) Build'
      model: '$1'
    - regex: 'Celkon[\. _*]([^;/\)]+)[\)/]'
      model: '$1'

# Changhong
Changhong:
  regex: 'Changhong'
  device: 'tv'
  models:
    - regex: 'Changhong-([^);/]+)'
      model: '$1'

# Cherry Mobile
'Cherry Mobile':
  regex: 'Cherry|Flare2X|Fusion Bolt'
  device: 'smartphone'
  models:
    - regex: 'Cherry(?: ?Mobile)?[ _]?([^/;]+) Build'
      model: '$1'
    - regex: '(Flare2X)'
      model: '$1'
    - regex: '(Fusion Bolt)'
      model: '$1'
      device: 'tablet'

# Compal
Compal:
  regex: 'Compal-[a-z0-9]+'
  device: 'feature phone'
  model: '$1'

# ConCorde
ConCorde:
  regex: 'ConCorde ([^/;]+) Build'
  device: 'smartphone'
  models:
    - regex: 'ConCorde Tab ?([^/;]+) Build'
      model: 'Tab $1'
      device: 'tablet'
    - regex: 'ConCorde ReadMan ?([^/;]+) Build'
      model: 'ReadMan $1'
      device: 'tablet'
    - regex: 'ConCorde ([^/;]+) Build'
      model: '$1'

# Coolpad
Coolpad:
  regex: '(?:YL-)?Coolpad|8190Q[ ;/\)]|8295 Build'
  device: 'smartphone'
  models:
    - regex: '8190Q[ ;/\)]'
      model: '8190Q'
    - regex: '8295 Build'
      model: '8295'
    - regex: '(?:YL-)?Coolpad[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: '(?:YL-)?Coolpad[ _\-]?([a-z0-9\-]+)'
      model: '$1'

# Cricket
Cricket:
  regex: 'Cricket-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Crius
'Crius Mea':
  regex: '(Q7A\+?)[);/ ]'
  device: 'tablet'
  model: '$1'

# Crosscall
Crosscall:
  regex: 'Crosscall'
  device: 'smartphone'
  models:
    - regex: 'Crosscall ([^;/]+) Build'
      model: '$1'

# Cube
Cube:
  regex: 'Cube|(U[0-9]+GT|K8GT)'
  device: 'tablet'
  models:
    - regex: 'U27GT'
      model: 'Talk 8'
    - regex: 'U55GT'
      model: 'Talk 79'
    - regex: 'U65GT'
      model: 'Talk 9X'

    - regex: '(U[0-9]+GT[^;/]*) Build'
      model: '$1'
    - regex: '(U[0-9]+GT(?:[0-9]|[\-_][a-z]+)?)'
      model: '$1'
    - regex: '(K8GT)'
      model: '$1'

# CUBOT
CUBOT:
  regex: 'CUBOT'
  device: 'smartphone'
  models:
    - regex: 'CUBOT ([^;/]+) Build'
      model: '$1'
    - regex: '([^;/]+) Build/CUBOT'
      model: '$1'

# Datang
Datang:
  regex: 'DATANG'
  device: 'smartphone'
  models:
    - regex: '(?:DATANG[ _-])+([^;/]+) Build'
      model: '$1'
    - regex: '(?:DATANG[ _-])+([^;/)]+)[;/)]'
      model: '$1'

# Danew
Danew:
  regex: 'Dslide ?([^;/]+) Build'
  device: 'tablet'
  model: 'DSlide $1'

# Denver Electronics
Denver:
  regex: '(TA[CDQ]-[0-9]+)'
  device: 'tablet'
  model: '$1'

# Dell
Dell:
  regex: 'Dell|Venue'
  device: 'smartphone'
  models:
    - regex: '(?:Dell )?(Streak|Venue) ?([^/;]*) Build'
      model: '$1 $2'
      device: 'tablet'
    - regex: 'Dell; ((?:Streak|Venue)[^;/\)]*)'
      model: '$1'
      device: 'tablet'
    - regex: 'Dell; ([^;/\)]+)'
      model: '$1'
    - regex: 'Dell[ _\-]([^/;]+) Build'
      model: '$1'

# Desay
Desay:
  regex: 'Desay'
  device: 'smartphone'
  models:
    - regex: 'Desay[ _-]?([^;/)]+) Build'
      model: '$1'
    - regex: 'Desay[ _-]?([^;/)]+)[);/ ]'
      model: '$1'

# Dbtel
Dbtel:
  regex: 'DBTEL(?:[\-/])?([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Dicam
Dicam:
  regex: 'DICAM-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# DoCoMo
DoCoMo:
  regex: 'DoCoMo|\;FOMA|KGT/1\.0'
  device: 'feature phone'
  models:
    - regex: 'DoCoMo/[12]\.0[/ ]([a-z0-9]+)'
      model: '$1'
    - regex: '([a-z0-9]+)(?:_W)?\;FOMA'
      model: '$1'
    - regex: 'KGT/1\.0 ([a-z0-9]+)'
      model: '$1'

# Doogee
Doogee:
  regex: 'DOOGEE[ _-]|((?:BIGBOY|COLLO[23]?|DAGGER|DISCOVERY2?|FIND|HOTWIND|LATTE|MAX|MINT|MOON|PIXELS|RAINBOX|TURBO|VALENCIA|VOYAGER2?|TITANS))[ -](DG[0-9]+C?)[);/ ]'
  device: 'smartphone'
  models:
    - regex: '(?:DOOGEE[ _-])?((?:BIGBOY|COLLO[23]?|DAGGER|DISCOVERY2?|FIND|HOTWIND|LATTE|MAX|MINT|MOON|PIXELS|RAINBOX|TURBO|VALENCIA|VOYAGER2?|TITANS))[ -](DG[0-9]+C?)[);/ ]'
      model: '$1 $2'
    - regex: 'DOOGEE[ _-]([^);/]+) Build'
      model: '$1'
    - regex: 'DOOGEE[ _-]([^);/]+)[);/ ]'
      model: '$1'

# Doov
Doov:
  regex: '(?:Doov-)?Doov[ _]'
  device: 'smartphone'
  models:
    - regex: '(?:Doov-)?Doov[ _]([^;/]+) Build'
      model: '$1'
    - regex: '(?:Doov-)?Doov[ _]([^);/]+)[);/ ]'
      model: '$1'

# Dopod
Dopod:
  regex: 'Dopod(?: )?([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Dune HD
'Dune HD':
  regex: 'DuneHD'
  device: 'tv'
  models:
    - regex: 'DuneHD/\d.\d \([a-z]+__([a-z0-9_-]+);'
      model: '$1'
    - regex: 'DuneHD/\d.\d \(([a-z0-9_-]+);'
      model: '$1'

# E-Boda
E-Boda:
  regex: 'E-Boda'
  device: 'smartphone'
  models:
    - regex: 'E-Boda ((?:Revo|Izzycomm|Essential|Intelligence|Supreme)[^/;]+) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'E-Boda ([^/;]+) Build'
      model: '$1'

# Easypix
Easypix:
  regex: 'EasyPad|EasyPhone'
  device: 'smartphone'
  models:
    - regex: '(EasyPhone[^/;]+) Build'
      model: '$1'
    - regex: '(EasyPad[^/;]+) Build'
      model: '$1'
      device: 'tablet'

# Ebest
EBEST:
  regex: 'EBEST'
  device: 'smartphone'
  models:
    - regex: 'EBEST[ _-]?([^;/)]+) Build'
      model: '$1'
    - regex: 'EBEST[ _-]?([^;/)]+)[);/ ]'
      model: '$1'

# ECS
ECS:
  regex: '(?:TA10CA3|TM105A?|TR10CS1)[);/ ]'
  device: 'tablet'
  models:
    - regex: 'TA10CA3[);/ ]'
      model: 'TA10CA3'
    - regex: 'TR10CS1[);/ ]'
      model: 'TR10CS1'
    - regex: 'TM105A[);/ ]'
      model: 'TM105A'
    - regex: 'TM105[);/ ]'
      model: 'TM105'

# Elephone
Elephone:
  regex: 'Elephone[ _\-]([^/;]+) Build'
  device: 'smartphone'
  model: '$1'

# Energy Sistem
'Energy Sistem':
  regex: 'ENERGY[ _-]?([^;/]+) Build'
  device: 'tablet'
  model: '$1'

# Ericy
Ericy:
  regex: 'Ericy-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Eton
Eton:
  regex: 'Eton'
  device: 'smartphone'
  models:
    - regex: 'Eton[ _-]?([^;/)]+) Build'
      model: '$1'
    - regex: 'Eton[ _-]?([^;/)]+)[);/ ]'
      model: '$1'

# Rikomagic
Rikomagic:
  regex: 'MK(80[28][^/;]*) Build'
  device: 'tv'
  model: 'MK$1'

# Sony & Sony Ericsson (combined as they are mixed up)
Sony:
  regex: 'Sony(?: ?Ericsson)?|SGP|Xperia|C1[569]0[45]|C2[01]0[45]|C2305|C530[236]|C550[23]|C6[56]0[236]|C6616|C68(?:0[26]|[34]3)|C69(?:0[236]|16|43)|D200[45]|D21(?:0[45]|14)|D22(?:0[236]|12|43)|D230[2356]|D240[36]|D25(?:02|33)|D510[236]|D530[36]|D5322|D5503|D58[03]3|D65(?:0[23]|43)|D66[05]3|E2303|E6553|(?:WT|LT|SO|ST|SK|MK)[0-9]+[a-z]*[0-9]*(?: Build|\))|X?L39H|XM50[ht]|W960|portalmmm/2\.0 K|S3[69]h|X10[ia]v?|E1[05][ai]v?|MT[0-9]{2}[a-z]? Build|SO-0(?:[345]D|[234]E|[12]C|[1235]F|[12]G)|R800[aix]|LiveWithWalkman'
  device: 'smartphone'
  models:
    # SONY ERICSSON: explicit smartphone models
    - regex: '(?:Sony(?:Ericsson)?)?E10[ai]v?'
      model: 'Xperia X10 mini'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?U20'
      model: 'Xperia X10 mini pro'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?E15[ai]v?'
      model: 'Xperia X8'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?(LT15[ai]?v?|SO-01C)'
      model: 'Xperia arc'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?LT18[ai]v?'
      model: 'Xperia arc S'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?MT11'
      model: 'Xperia neo V'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?MT15'
      model: 'Xperia neo'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?MT27'
      model: 'Xperia Sola'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?MK16[ai]'
      model: 'Xperia pro'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?ST15[ai]'
      model: 'Xperia mini'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?ST17[ai]'
      model: 'Xperia active'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?ST18[ai]'
      model: 'Xperia ray'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?SK17[ai]?'
      model: 'Xperia mini pro'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?X10[ai]v?'
      model: 'Xperia X10'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)M1'
      model: 'Aspen'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?R800'
      model: 'Xperia PLAY'
      brand: 'Sony Ericsson'
    - regex: '(?:Sony(?:Ericsson)?)?WT19|LiveWithWalkman'
      model: 'Live with Walkman'
      brand: 'Sony Ericsson'

    # SONY ERICSSON: explicit feature phone models
    - regex: '(?:Sony(?:Ericsson)?)?CK13i'
      model: 'txt'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?CK15[ai]'
      model: 'txt pro'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?F100i'
      model: 'Jalou'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?J105'
      model: 'Naite'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?J108'
      model: 'Cedar'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?J10'
      model: 'Elm'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?J20'
      model: 'Hazel'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?U10'
      model: 'Aino'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?U100'
      model: 'Yari'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?U1'
      model: 'Satio'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?U5'
      model: 'Vivaz'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?U8'
      model: 'Vivaz pro'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?W20'
      model: 'Zylo'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?W100'
      model: 'Spiro'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?W150'
      model: 'Yendo'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?W960'
      model: 'W960'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: '(?:Sony(?:Ericsson)?)?WT13'
      model: 'Mix Walkman'
      brand: 'Sony Ericsson'
      device: 'feature phone'

    # SONY: explicit smartphone models
    - regex: '(?:Sony(?:Ericsson)?)?LT22i'
      model: 'Xperia P'
    - regex: '(?:Sony(?:Ericsson)?)?LT25i'
      model: 'Xperia V'
    - regex: '(?:Sony(?:Ericsson)?)?LT26ii'
      model: 'Xperia SL'
    - regex: '(?:Sony(?:Ericsson)?)?LT26i'
      model: 'Xperia S'
    - regex: '(?:Sony(?:Ericsson)?)?SO-02C'
      model: 'Xperia arco'
    - regex: '(?:Sony(?:Ericsson)?)?SO-03D'
      model: 'Xperia arco HD'
    - regex: '(?:Sony(?:Ericsson)?)?LT26w'
      model: 'Xperia arco S'
    - regex: '(?:Sony(?:Ericsson)?)?LT28[aih]'
      model: 'Xperia ion'
    - regex: '(?:Sony(?:Ericsson)?)?LT29i'
      model: 'Xperia TX'
    - regex: '(?:Sony(?:Ericsson)?)?LT30a'
      model: 'Xperia T LTE'
    - regex: '(?:Sony(?:Ericsson)?)?LT30p'
      model: 'Xperia T'
    - regex: '(?:Sony(?:Ericsson)?)?ST21[ia]2'
      model: 'Xperia tipo dual'
    - regex: '(?:Sony(?:Ericsson)?)?ST21[ia]'
      model: 'Xperia tipo'
    - regex: '(?:Sony(?:Ericsson)?)?ST23[ia]'
      model: 'Xperia miro'
    - regex: '(?:Sony(?:Ericsson)?)?ST25[ia]'
      model: 'Xperia U'
    - regex: '(?:Sony(?:Ericsson)?)?ST26[ia]'
      model: 'Xperia J'
    - regex: '(?:Sony(?:Ericsson)?)?ST27[ia]'
      model: 'Xperia go'
    - regex: '(?:Sony(?:Ericsson)?)?C150[45]'
      model: 'Xperia E'
    - regex: '(?:Sony(?:Ericsson)?)?C160[45]'
      model: 'Xperia E Dual'
    - regex: '(?:Sony(?:Ericsson)?)?C190[45]'
      model: 'Xperia M'
    - regex: '(?:Sony(?:Ericsson)?)?C200[45]'
      model: 'Xperia M Dual'
    - regex: '(?:Sony(?:Ericsson)?)?C210[45]|S36h'
      model: 'Xperia L'
    - regex: '(?:Sony(?:Ericsson)?)?C2305|S39h'
      model: 'Xperia C'
    - regex: '(?:Sony(?:Ericsson)?)?C530[236]'
      model: 'Xperia SP'
    - regex: '(?:Sony(?:Ericsson)?)?C550[23]'
      model: 'Xperia ZR'
    - regex: '(?:Sony(?:Ericsson)?)?C650[236]'
      model: 'Xperia ZL'
    - regex: '(?:Sony(?:Ericsson)?)?(?:C66(?:0[236]|16)|SO-02E)'
      model: 'Xperia Z'
    - regex: '(?:Sony(?:Ericsson)?)?(?:C68(?:0[26]|[34]3)|XL39H)'
      device: 'phablet'
      model: 'Xperia Z Ultra'
    - regex: '(?:Sony(?:Ericsson)?)?(?:C69(?:0[236]|16|43)|L39H|SO-0[12]F)'
      model: 'Xperia Z1'
    - regex: '(?:Sony(?:Ericsson)?)?D200[45]'
      model: 'Xperia E1'
    - regex: '(?:Sony(?:Ericsson)?)?D21(?:0[45]|14)'
      model: 'Xperia E1 Dual'
    - regex: '(?:Sony(?:Ericsson)?)?D22(?:0[236]|43)'
      model: 'Xperia E3'
    - regex: '(?:Sony(?:Ericsson)?)?D2212'
      model: 'Xperia E3 Dual'
    - regex: '(?:Sony(?:Ericsson)?)?D2302'
      model: 'Xperia M2 Dual'
    - regex: '(?:Sony(?:Ericsson)?)?D230[356]'
      model: 'Xperia M2'
    - regex: '(?:Sony(?:Ericsson)?)?D240[36]'
      model: 'Xperia M2 Aqua'
    - regex: '(?:Sony(?:Ericsson)?)?E2303'
      model: 'Xperia M4 Aqua'
    - regex: '(?:Sony(?:Ericsson)?)?D2502'
      model: 'Xperia C3 Dual'
    - regex: '(?:Sony(?:Ericsson)?)?D2533'
      model: 'Xperia C3'
    - regex: '(?:Sony(?:Ericsson)?)?D510[236]'
      model: 'Xperia T3'
    - regex: '(?:Sony(?:Ericsson)?)?D530[36]|XM50[ht]'
      model: 'Xperia T2 Ultra'
      device: 'phablet'
    - regex: '(?:Sony(?:Ericsson)?)?D5322'
      model: 'Xperia T2 Ultra Dual'
      device: 'phablet'
    - regex: '(?:Sony(?:Ericsson)?)?D5503'
      model: 'Xperia Z1 Compact'
    - regex: '(?:Sony(?:Ericsson)?)?(?:D58[03]3|SO-02G)'
      model: 'Xperia Z3 Compact'
    - regex: '(?:Sony(?:Ericsson)?)?(?:D65(?:0[23]|43)|SO-03F)'
      model: 'Xperia Z2'
    - regex: '(?:Sony(?:Ericsson)?)?(?:D66[05]3|SO-01G)'
      model: 'Xperia Z3'
    - regex: '(?:Sony(?:Ericsson)?)?(?:E6553)'
      model: 'Xperia Z3+'
    - regex: '(?:Sony(?:Ericsson)?)?SO-04E'
      model: 'Xperia A'
    - regex: '(?:Sony(?:Ericsson)?)?SO-04D'
      model: 'Xperia GX'
    - regex: '(?:Sony(?:Ericsson)?)?SO-05D'
      model: 'Xperia SX'

    # SONY: explicit tablet models
    - regex: 'SGP(?:311|312|321)[);/ ]|SO-03E'
      model: 'Xperia Tablet Z'
      device: 'tablet'
    - regex: 'SGP(?:511|512|521)[);/ ]|SO-05F'
      model: 'Xperia Tablet Z2'
      device: 'tablet'
    - regex: 'SGP(?:6[24]1)[);/ ]'
      model: 'Xperia Tablet Z3 Compact'
      device: 'tablet'
    - regex: 'SGPT(?:12|121|122|123|13|131|132|133)[);/ ]'
      model: 'Xperia Tablet S'
      device: 'tablet'

    # general detections
    - regex: 'SonyBDP|SonyDBV'
      model: 'Blu-ray Player'
      device: 'tv'
    - regex: '(?:Sony-)?(KDL?-?[0-9a-z]+)'
      model: '$1'
      device: 'tv'
    - regex: 'Opera TV Store.*(?:Sony-)([0-9a-z-_]+)'
      model: '$1'
      device: 'tv'
    - regex: '((?:WT|SO|ST|SK|MK)[0-9]+[a-z]*[0-9]*)(?: Build|\))'
      model: '$1'
      brand: 'Sony Ericsson'
    - regex: '(MT[0-9]{2}[a-z]?)[);/ ]'
      model: '$1'
      brand: 'Sony Ericsson'
    - regex: 'portalmmm/2.0 K([a-z0-9]+)'
      model: 'K$1'
      brand: 'Sony Ericsson'
    - regex: 'Sony ?Ericsson?([^/;]*) Build'
      model: '$1'
      brand: 'Sony Ericsson'
    - regex: 'SonyEricsson([CGJKPTWZ][0-9]+[a-z]+)/'
      model: '$1'
      brand: 'Sony Ericsson'
      device: 'feature phone'
    - regex: 'Sony ?Ericsson ?([a-z0-9\-]+)'
      model: '$1'
      brand: 'Sony Ericsson'

    - regex: 'Sony (Tablet[^/;]*) Build'
      model: '$1'
      device: 'tablet'
    - regex: '(SGP[^/;]*) Build'
      model: '$1'
      device: 'tablet'
    - regex: 'Xperia ([^/;]*Tablet[^/;]*) Build'
      model: 'Xperia $1'
      device: 'tablet'
    - regex: 'Xperia ([^;/]+) Build'
      model: 'Xperia $1'
    - regex: 'Sony[ -]?([^/;]*) Build'
      model: '$1'
    - regex: 'Sony[ -]?([a-z0-9\-]+)'
      model: '$1'

# Ericsson
Ericsson:
  regex: '(?:Ericsson(?:/ )?[a-z0-9]+)|(?:R380 2.0 WAP1.1)'
  device: 'feature phone'
  models:
    - regex: 'Ericsson(?:/ )?([a-z0-9]+)'
      model: '$1'
    - regex: 'R380 2.0 WAP1.1'
      model: 'R380'

# eTouch
eTouch:
  regex: 'eTouch ?([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# Storex
Storex:
  regex: "eZee[^a-z]*Tab ?([^;/]*) Build|STOREX LinkBox"
  device: 'tablet'
  models:
    - regex: "eZee[^a-z]*Tab ?([^;/]*) Build"
      model: "eZee'Tab$1"
    - regex: 'STOREX LinkBox'
      model: 'LinkBox'
      device: 'tv'

# Evertek
Evertek:
  regex: '(Ever(?:Glory|Shine|Miracle|Mellow|Classic|Trendy|Fancy|Vivid|Slim|Glow|Magic|Smart|Star)[^/;]*) Build|E70[25]0HD|E805[01]HD|E9054HD|E8050HG|E7914HG'
  device: 'smartphone'
  models:
    - regex: '(E70[25]0HD|E805[01]HD|E9054HD|E8050HG|E7914HG)'
      device: 'tablet'
      model: 'Everpad $1'
    - regex: '(Ever(?:Glory|Shine|Miracle|Mellow|Classic|Trendy|Fancy|Vivid|Slim|Glow|Magic|Smart|Star)[^/;]*) Build'
      model: '$1'

# Ezze
Ezze:
  regex: 'EZZE-|EZ[a-z0-9]+'
  device: 'feature phone'
  models:
    - regex: 'EZZE-([a-z0-9]+)'
      model: '$1'
    - regex: 'EZ([a-z0-9]+)'
      model: 'EZ$1'

# Ezio
Ezio:
  regex: 'EZIO-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Foxconn
Foxconn:
  regex: 'InFocus M[0-9]+[a-z]?'
  device: 'smartphone'
  models:
    - regex: 'InFocus M([0-9]+[a-z]?)'
      model: 'InFocus M$1'

# Fujitsu
Fujitsu:
  regex: 'F-01F|F-02[EF]|F-05[DE]|F-06E|F-08D|F-09E'
  device: 'smartphone'
  models:
    - regex: 'F-01F'
      model: 'Arrows NX F-01F'
    - regex: 'F-02E'
      model: 'Arrows X F-02E'
    - regex: 'F-05D'
      model: 'Arrows X LTE F-05D'
    - regex: 'F-06E'
      model: 'Arrows NX F-06E'
    - regex: 'F-08D'
      model: 'F-08D Disney Mobile'
    - regex: 'F-09E'
      model: 'Raku-Raku Smartphone Premium F-09E'
    - regex: 'F-12C'
      model: 'F-12C'

    - regex: 'F-02F'
      model: 'Arrows Tab F-02F'
      device: 'tablet'
    - regex: 'F-05E'
      model: 'Arrows Tab F-05E'
      device: 'tablet'

# Gemini
Gemini:
  regex: '(GEM[0-9]+[a-z]*)'
  device: 'tablet'
  model: '$1'

# Gigabyte
Gigabyte:
  regex: 'GSmart [a-z0-9 ]+ Build|Gigabyte-[a-z0-9]+'
  device: 'smartphone'
  models:
    - regex: '(GSmart [a-z0-9 ]+) Build'
      model: '$1'
    - regex: 'Gigabyte-([a-z0-9]+)'
      model: '$1'

# Gigaset
Gigaset:
  regex: 'Gigaset QV(1030|830)'
  device: 'tablet'
  model: 'Gigaset QV$1'

# Gionee
Gionee:
  regex: '(?:GIO-)?GIONEE[ _-]?[a-z0-9]+|(?:Dream_D1|V188S?|GN[0-9]{3,4}[a-z]?)[);/ ]'
  device: 'smartphone'
  models:
    - regex: 'GN810[);/ ]'
      model: 'GN810'
      device: 'phablet'
    - regex: 'GN([0-9]{3,4}[a-z]?)[);/ ]'
      model: 'GN$1'
    - regex: 'V188S[);/ ]'
      model: 'V188S'
    - regex: 'V188[);/ ]'
      model: 'V188'
    - regex: '(?:(?:GIO-)?GIONEE[ _-])?Dream_D1[);/ ]'
      model: 'Dream D1'
    - regex: '(?:GIO-)?GIONEE[ _-]([a-z0-9_-]+).*Android'
      model: '$1'
    - regex: 'Android.*(?:GIO-)?GIONEE[ _-]([a-z0-9_-]+)'
      model: '$1'
    - regex: '(?:GIO-)?GIONEE[ _-]?([a-z0-9]+)'
      model: '$1'
      device: 'feature phone'

# Vizio
Vizio:
  regex: 'Vizio|VAP430|VTAB1008'
  device: 'tv'
  models:
    - regex: 'VAP430'
      model: 'VAP430'
    - regex: 'VTAB1008'
      device: 'tablet'
      model: 'VTAB1008'

# GOCLEVER
GOCLEVER:
  regex: 'GOCLEVER|QUANTUM|ARIES|INSIGNIA'
  device: 'smartphone'
  models:
    - regex: '((?:QUANTUM|ARIES|INSIGNIA)[ _-]?[^;/]+) Build'
      model: '$1'
    - regex: 'GOCLEVER[ _-]TAB[ _-]?([^;/]+) Build'
      model: 'TAB $1'
      device: 'tablet'
    - regex: 'GOCLEVER[ _-]?([^;/]+) Build'
      model: '$1'
    - regex: 'TAB ([^;/)]+) Build/GOCLEVER'
      model: 'TAB $1'
      device: 'tablet'
    - regex: '([^;/)]+) Build/GOCLEVER'
      model: '$1'
    - regex: 'GOCLEVER[ _-]?TAB[ _-]([^;/)]+)[;/)]'
      model: 'TAB $1'
      device: 'tablet'
    - regex: 'GOCLEVER[ _-]?([^;/)]+)[;/)]'
      model: '$1'

# Goly
Goly:
  regex: 'Goly[ _-]'
  device: 'smartphone'
  models:
    - regex: 'Goly[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Goly[ _-]([^;/)]+)[;/)]'
      model: '$1'

# Google
Google:
  regex: 'Nexus|GoogleTV|Glass|CrKey[^a-z0-9]'
  device: 'smartphone'
  models:
    - regex: 'Glass'
      model: 'Glass'
    - regex: 'Galaxy Nexus'
      model: 'Galaxy Nexus'
    - regex: '(Nexus (?:S|4|5X?|One))'
      model: '$1'
    - regex: '(Nexus (?:6P?))'
      device: 'phablet'
      model: '$1'
    - regex: '(Nexus (?:7|9|10))'
      device: 'tablet'
      model: '$1'
    - regex: 'CrKey[^a-z0-9]'
      model: 'Chromecast'
      device: 'tv'
    - regex: 'GoogleTV'
      device: 'tv'
      model: 'GoogleTV'

# Gradiente
Gradiente:
  regex: 'GRADIENTE'
  device: 'feature phone'
  models:
    - regex: 'GRADIENTE-([a-z0-9]+)'
      model: '$1'
    - regex: 'GRADIENTE ([a-z0-9\-]+)'
      model: '$1'

# Grundig
Grundig:
  regex: 'GR?-TB[0-9]+[a-z]*|GRUNDIG|portalmmm/2\.0 G'
  device: 'tv'
  models:
    - regex: '(GR?-TB[0-9]+[a-z]*)'
      device: 'tablet'
      model: '$1'
    - regex: 'GRUNDIG ([a-z0-9]+)'
      model: '$1'
    - regex: 'portalmmm/2\.0 G([a-z0-9]+)'
      model: 'G$1'

# Haier
Haier:
  regex: 'Haier|(?:HW-)?W(?:716|757|860|970)[);/ ]'
  device: 'smartphone'
  models:
    - regex: '(?:HW-)?W(716|757|860|970)[);/ ]'
      model: 'W$1'
    - regex: 'Haier[ _\-](H[WT]-[^/;]+) Build'
      model: '$1'
    - regex: 'Haier[ _\-](H[WT]-[a-z0-9_\-]+)'
      model: '$1'
    - regex: 'Haier[ _\-](sy[0-9]+)'
      model: '$1'
    - regex: 'Haier[ _\-]([a-z0-9\-]+)'
      model: '$1'
      device: 'feature phone'

# Hasee
Hasee:
  regex: 'Hasee'
  device: 'smartphone'
  models:
    - regex: 'Hasee ([^;/]+) Build'
      model: '$1'
    - regex: 'Hasee ([^;/)]+)[);/ ]'
      model: '$1'

# Hisense
Hisense:
  regex: '(?:HS-)?Hisense ([^;/]+) Build|HS-(?:U|EG?|I|T|X)[0-9]+[a-z0-9\-]*|E270BSA|M470BS[AE]|E2281'
  device: 'smartphone'
  models:
    # explicit tablet models
    - regex: 'E270BSA'
      device: 'tablet'
      model: 'Sero 7'
    - regex: 'M470BS[AE]'
      device: 'tablet'
      model: 'Sero 7 Pro'
    - regex: 'E2281'
      device: 'tablet'
      model: 'Sero 8'

    - regex: '(HS-(?:U|EG?|I|T|X)[0-9]+[a-z0-9\-]*)'
      model: '$1'
    - regex: '(?:HS-)?Hisense ([^;/]+) Build'
      model: '$1'

# Hi-Level
Hi-Level:
  regex: 'HLV-T([a-z0-9]+)'
  device: 'tablet'
  model: 'HLV-T$1'

# Hosin
Hosin:
  regex: 'HOSIN[ _-]'
  device: 'smartphone'
  models:
    - regex: 'HOSIN[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'HOSIN[ _-]([^;/]+)[;/)]'
      model: '$1'

# Huawei
Huawei:
  regex: '(HW-)?(?:Huawei|Ideos|Honor[ _]|(?:H60-L(?:01|02|03|04|11|12)|H30-(?:C00|L01M?|L02|U10|T00|T10)|G621-TL00M?|PLK-(?:AL10|CL00|TL00|TL01H?|UL00|L01)|SCL-(?:AL00|CL00|TL00H?)|CH(?:E2?|M)-[CUT]L00[HM]?|CHE1-CL[12]0|CHE2-L11)[);/ ])'
  device: 'smartphone'
  models:
    - regex: 'CHE2?-[UT]L00[HM]?|CHE1-CL[12]0|CHE2-L11'
      model: 'Honor 4X'
    - regex: 'CHM-[CUT]L00[HM]?'
      model: 'Honor Play 4C'
    - regex: '(?:Honor_|HW-)?G621-TL00M?[);/ ]'
      model: 'G621'
    - regex: '(?:Honor_|HW-)?H30-(?:C00|L01M?|L02|U10|T00|T10)(?:_TD)?[);/ ]'
      model: 'Honor 3C'
    - regex: '(?:Honor_|HW-)?SCL-(?:AL00|CL00|TL00H?)(?:_TD)?[);/ ]'
      model: 'Honor 4A'
    - regex: '(?:Honor_|HW-)?H60-L(?:01|02|03|04|11|12)(?:_TD)?[);/ ]'
      model: 'Honor 6'
    - regex: '(?:Honor_|HW-)?PLK-(?:AL10|CL00|TL00|TL01H?|UL00|L01)[);/ ]'
      model: 'Honor 7'
    - regex: '(MediaPad[^/;]*) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'Ideos([^;/]*) Build'
      model: 'Ideos$1'
    - regex: 'HUAWEI MT([0-9]+)'
      device: 'phablet'
      model: 'Ascend Mate $1'
    - regex: 'Huawei[ _\-]?([^/;]*) Build'
      model: '$1'
    - regex: '(?:HW-)?Huawei(?:/1\.0/0?(?:Huawei))?[_\- /]?([a-z0-9\-_]+)'
      model: '$1'
    - regex: 'Huawei; ([a-z0-9 \-]+)'
      model: '$1'

# Hyundai
Hyundai:
  regex: 'Hyundai'
  device: 'tablet'
  models:
    - regex: 'Hyundai ([^;/]+) Build'
      model: '$1'

#i-Joy
'i-Joy':
  regex: 'i-Joy|i-Call|(?:Neon[79]|Sygnus|Deox|Elektra (?:M|L|XL|XXL))[);/ ]'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'Elektra M[);/ ]'
      model: 'Elektra M'
    - regex: 'Elektra L[);/ ]'
      model: 'Elektra L'
    - regex: 'Elektra XL[);/ ]'
      model: 'Elektra XL'
    - regex: 'Elektra XXL[);/ ]'
      model: 'Elektra XXL'
      device: 'phablet'

    # explicit tablet models
    - regex: 'Neon([79])[);/ ]'
      model: 'Neon $1'
      device: 'tablet'
    - regex: 'Sygnus[);/ ]'
      model: 'Sygnus'
      device: 'tablet'
    - regex: 'Deox[);/ ]'
      model: 'Deox'
      device: 'tablet'

    - regex: 'i-Call ([^;/]+) Build'
      model: 'i-Call $1'
    - regex: 'i-Joy ([^;/]+) Build'
      model: '$1'

# iBall
iBall:
  regex: 'iBall[ _]([^/;]*)[ _]Build'
  device: 'tablet'
  model: '$1'

iBerry:
  regex: 'AUXUS ([^/;]+) Build'
  device: 'smartphone'
  models:
    - regex: 'AUXUS (Core[^/;]+) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'AUXUS ([^/;]+) Build'
      model: '$1'

# Infinix
Infinix:
  regex: 'Infinix'
  device: 'smartphone'
  models:
    - regex: 'Infinix (X[78]00)'
      device: 'tablet'
      model: '$1'
    - regex: 'Infinix (X\d+)'
      model: '$1'
    - regex: 'Infinix[ _]([a-z0-9_\-]+)'
      model: '$1'

# Inkti
Inkti:
  regex: 'intki[ _]([^/;]*)[ _]Build'
  device: 'smartphone'
  model: '$1'

# Innostream
Innostream:
  regex: 'INNO([a-z0-9]+)'
  device: 'feature phone'
  model: 'INNO$1'

# Inq
INQ:
  regex: 'INQ[/ ]'
  device: 'feature phone'
  models:
    - regex: 'INQ/([a-z0-9\-]+)'
      model: '$1'
    - regex: 'INQ ([^;/]+) Build'
      model: '$1'
      device: 'smartphone'

# Intex
Intex:
  regex: 'Intex|(Aqua|Cloud)[ _\.]([^/;\)]+)(?:[ _]Build|(?<!Build)/|\))'
  device: 'smartphone'
  models:
    - regex: 'Intex[ _]([^/;]*)[ _]Build'
      model: '$1'
    - regex: '(Aqua|Cloud)[ _\.]([^/;\)]+)(?:[ _]Build|(?<!Build)/|\))'
      model: '$1 $2'
    - regex: 'Intex[ _]([a-z0-9_+\-]+)'
      model: '$1'

# i-mate
i-mate:
  regex: 'i-mate ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# i-mobile
i-mobile:
  regex: 'i-mobile ?[a-z0-9]+|i-Style'
  device: 'feature phone'
  models:
    - regex: 'i-mobile (i-note[^/;]*) Build'
      model: '$1'
      device: 'tablet'
    - regex: 'i-Style ?([^;/]+) Build'
      model: 'i-Style $1'
      device: 'smartphone'
    - regex: 'i-mobile (IQ[^/;]*) Build'
      model: '$1'
      device: 'smartphone'
    - regex: 'i-mobile(?: )?([a-z0-9\- ]+) Build'
      model: '$1'
    - regex: 'i-mobile(?: )?([a-z0-9]+)'
      model: '$1'

# ikomo
iKoMo:
  regex: 'iKoMo ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# iOcean
iOcean:
  regex: 'iOCEAN'
  device: 'smartphone'
  models:
    - regex: 'iOCEAN[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'iOCEAN[ _\-]?([^);/ ]+)'
      model: '$1'

# iTel
iTel:
  regex: 'itel|iNote'
  device: 'smartphone'
  models:
    - regex: 'iNote ([^/;]*)Build'
      model: 'iNote $1'
    - regex: 'iNote_([a-z0-9\-_]+)'
      model: 'iNote $1'
    - regex: 'iTel ([^/;]*)Build'
      model: '$1'
    - regex: 'iTel_([a-z0-9\-_]*)'
      model: '$1'

#Jiayu
Jiayu:
  regex: '(JY-[a-z0-9]+)[);/ ]'
  device: 'smartphone'
  model: '$1'

# Jolla
Jolla:
  regex: 'Jolla'
  device: 'smartphone'
  model: ''

# Kazam
Kazam:
  regex: 'Kazam ([^;/]+) Build|Trooper_X[0-9][0-9][);/ ]|Tornado 348'
  device: 'smartphone'
  models:
    - regex: 'Tornado 348'
      model: 'Tornado 348'
    - regex: 'Trooper_X([0-9])([0-9])[);/ ]'
      model: 'Trooper X$1.$2'
    - regex: 'Kazam ([^;/]+) Build'
      model: '$1'

# Kingsun
Kingsun:
  regex: 'Kingsun[ _-]'
  device: 'smartphone'
  models:
    - regex: 'Kingsun[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Kingsun[ -]((?!Build)[a-z0-9_-]+)'
      model: '$1'

# Komu
Komu:
  regex: 'Komu[ -]'
  device: 'smartphone'
  models:
    - regex: 'Komu[ -]([^;/]+) Build'
      model: '$1'
    - regex: 'Komu[ -]([a-z0-9_-]+)'
      model: '$1'

# Koobee
Koobee:
  regex: 'Koobee'
  device: 'smartphone'
  models:
    - regex: 'Koobee[ _\-]?([^;/]+) Build'
      model: '$1'
    - regex: 'Koobee[ _\-]?([a-z0-9_-]+)'
      model: '$1'

# Kumai
Kumai:
  regex: '(?:KM-)?Kumai'
  device: 'smartphone'
  models:
    - regex: '(?:KM-)?Kumai[ _\-]?([^;/]+) Build'
      model: '$1'
    - regex: '(?:KM-)?Kumai[ _\-]?([a-z0-9_-]+)'
      model: '$1'

# KT-Tech
KT-Tech:
  regex: '(KM-[a-z0-9]+|EV-[a-z0-9]+)[);/ ]'
  device: 'smartphone'
  model: '$1'

# kddi
KDDI:
  regex: 'kddi-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# KOPO
KOPO:
  regex: 'KOPO[ _-]'
  device: 'smartphone'
  models:
    - regex: 'KOPO[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'KOPO[ _\-]?([^);/ ]+)'
      model: '$1'

# Koridy
Koridy:
  regex: 'KORIDY[ _-]([^/;]+) Build'
  device: 'smartphone'
  model: '$1'

#k-touch
K-Touch:
  regex: 'K-?Touch[ _][a-z0-9]+'
  device: 'smartphone'
  models:
    - regex: 'K-?Touch[ _]([^/;]*)[ _]Build'
      model: '$1'
    - regex: 'K-?Touch[ _]([a-z0-9]+)'
      model: '$1'

# kyocera
Kyocera:
  regex: 'Kyocera|KWC-|QC-|C5170|C5155|C5215|C6750|C6522N?|S2151'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'C5155'
      model: 'Rise'
    - regex: 'C5170'
      model: 'Hydro'
    - regex: 'C5215'
      model: 'Hydro EDGE'
    - regex: 'C6522N?'
      model: 'Hydro XTRM'
    - regex: 'C6750'
      model: 'Hydro ELITE'

    # explicit feature phone models
    - regex: 'S2151'
      model: 'Coast'
      device: 'feature phone'

    - regex: 'Kyocera-KZ-([a-z0-9]+)'
      model: 'KZ $1'
    - regex: 'Kyocera(?:[\-/])?([a-z0-9]+)'
      model: '$1'
    - regex: '(?:KWC|QC)-([a-z0-9]+)'
      model: '$1'

# Lava
Lava:
  regex: 'iris[ _]?([^/;]+)(?:\)| Build)'
  device: 'smartphone'
  models:
    - regex: 'iris[ _]?([^/;]+)(?:\)| Build)'
      model: 'Iris $1'

# lanix
Lanix:
  regex: 'LANIX-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# lct
LCT:
  regex: 'LCT_([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Le Pan
'Le Pan':
  regex: 'Le ?Pan|TC970 ([^;/]+)Build'
  device: 'tablet'
  models:
    - regex: 'TC802A'
      model: 'Le Pan Mini'
    - regex: 'TC970 ([^;/]+)Build'
      model: 'TC970 $1'
    - regex: 'Le ?Pan ?(II|S)[);/ ]'
      model: 'Le Pan $1'
    - regex: 'Le ?Pan ?([^;/]+) Build'
      model: '$1'

# lenco
Lenco:
  regex: 'Lenco ([^/;]*) Build'
  device: 'tablet'
  model: '$1'

# lenovo
Lenovo:
  regex: '(?:LNV-)?Lenovo|IdeaTab|IdeaPad|Thinkpad|Yoga Tablet'
  device: 'smartphone'
  models:
    - regex: 'Lenovo (B[0-9]+[^/;]*) Build'
      model: 'IdeaTab $1'
      device: 'tablet'
    - regex: 'ThinkPadTablet_(A[0-9]{3})_'
      model: 'ThinkPad Tablet $1'
      device: 'tablet'
    - regex: 'ThinkPad ?Tablet([^;/]*) Build'
      model: 'ThinkPad Tablet$1'
      device: 'tablet'
    - regex: 'IdeaPad ?([^;/]*) Build'
      model: 'IdeaPad $1'
      device: 'tablet'
    - regex: 'Lenovo ([^/;]*) Build'
      model: '$1'
    - regex: '(?:LNV-|Lenovo-)?Lenovo[ \-_]([a-z0-9_+\-]+)'
      model: '$1'
    - regex: 'IdeaTab[ \-_]?([a-z0-9]+)'
      model: 'IdeaTab $1'
      device: 'tablet'
    - regex: 'Yoga Tablet([^;/]+) Build'
      model: 'Yoga Tablet$1'
      device: 'tablet'

# lexibook
Lexibook:
  regex: '(MFC[0-9]{3}[a-z]{2,})'
  device: 'tablet'
  models:
    # Explicit tablet models
    - regex: 'MFC191FR'
      model: 'Tablet Ultra 3 XL'
    - regex: 'MFC045FR'
      model: 'TabTab'
    - regex: 'MFC163FR'
      model: 'Tablet Master 3'
    - regex: 'MFC142FR'
      model: 'Tablet Kids'
    - regex: 'MFC250FR'
      model: 'Tablet Junior'
    - regex: 'MFC270FR'
      model: 'Tablet Junior Power Touch'
    - regex: 'MFC280FR'
      model: 'Tablet Junior 2'
    - regex: 'MFC156FR'
      model: 'Tablet One'
    - regex: 'MFC155FR'
      model: 'Tablet Master'
    - regex: 'MFC157FR'
      model: 'Tablet Master 2'
    - regex: 'MFC17[05]FR'
      model: 'Tablet Ultra'
    - regex: 'MFC375FR'
      model: 'Tablet Ultra 2'
    - regex: 'MFC162FR'
      model: 'Power Tablet'
    - regex: 'MFC180FR'
      model: 'Tablet Advanced'
    - regex: 'MFC181FR'
      model: 'Tablet Advanced 2'
    - regex: 'MFC500FR'
      model: 'Tablet XL'
    - regex: 'MFC190BBFR'
      model: 'Barbie Tablet'
    - regex: 'MFC195DCFR'
      model: 'Tablet Disney Cars HD'
    - regex: 'MFC195FUFR'
      model: 'Furby Tablet'
    - regex: 'MFC195DPFR'
      model: 'Tablet Disney Princesse HD'
    - regex: 'MFC140FR'
      model: 'LapTab'
    - regex: 'MFC141FR'
      model: 'LapTab 2'

    - regex: '(MFC[0-9]{3}[a-z]{2,})'
      model: '$1'

# lg
LG:
  regex: 'LG|portalmmm/2\.0 (?:KE|KG|KP|L3)|VX[0-9]+|L-01D|L-07C'
  device: 'smartphone'
  models:
    - regex: 'L-01D'
      model: 'Optimus LTE L-01D'
    - regex: 'L-07C'
      model: 'Optimus Bright L-07C'

    - regex: 'LGE_DLNA_SDK|NetCast'
      device: 'tv'
      model: 'NetCast'
    - regex: 'LGE(?: |-LG| LG-AX|-)([a-z0-9]+)'
      model: '$1'
    - regex: 'LGE;([a-z0-9\-]+)'
      model: '$1'
    - regex: 'LG[ _\-](V90.*|Optimus[ _\-]Pad.*) Build'
      device: 'tablet'
      model: '$1'
    - regex: 'LG(?:/|-LG| |-)?([^/;]*) Build'
      model: '$1'
    - regex: 'LG(?:/|-LG| |-)?([a-z0-9]+)'
      model: '$1'
    - regex: 'LG; ([a-z0-9 ]+)'
      model: '$1'
    - regex: 'portalmmm/2.0 ((?:KE|KG|KP|L3)[a-z0-9]+)'
      model: '$1'
    - regex: '(VX[0-9]+)'
      model: '$1'

# Lingwin
Lingwin:
  regex: 'Lingwin[ _\-]'
  device: 'smartphone'
  models:
    - regex: 'Lingwin[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'Lingwin[ _\-]?([^);/ ]+)'
      model: '$1'

# Logicom
Logicom:
  regex: '(TAB950|TAB1062|E731|E812|E912|E1031)[);/ ]'
  device: 'tablet'
  model: '$1'

# microsoft
Microsoft:
  regex: 'KIN\.(One|Two)'
  device: 'feature phone'
  model: 'Kin $1'

# Konka
Konka:
  regex: 'KONKA[_ ]([a-z0-9]+)'
  device: 'smartphone'
  models:
    # Explicit smartphone models
    - regex: 'E5660S'
      model: 'Viva 5660s'
    - regex: 'W830'
      model: 'Tango 830'
    - regex: 'W(9[67]0)'
      model: 'Expose $1'
    - regex: 'W990'
      model: 'Tuxedo 990'

    - regex: 'KONKA[_ ]([a-z0-9]+)'
      device: 'feature phone'
      model: '$1'

# Karbonn
Karbonn:
  regex: '(?:Browser-)?Karbonn'
  device: 'smartphone'
  models:
    - regex: 'Karbonn ([a-z0-9]+) WAP-Browser'
      model: '$1'
      device: 'feature phone'
    - regex: 'WAP Browser-Karbonn ([a-z0-9]+)/'
      model: '$1'
      device: 'feature phone'
    - regex: 'Karbonn_([^;/)]+)'
      model: '$1'
    - regex: 'Karbonn ([^;/]+) Build'
      model: '$1'
    - regex: 'Karbonn ([^;/]+)/'
      model: '$1'

# Sagem
Sagem:
  regex: 'SAGEM|portalmmm/2.0 (?:SG|my)'
  device: 'smartphone'
  models:
    - regex: 'SAGEM-(my[a-z0-9\-]+)'
      model: '$1'
      device: 'feature phone'
    - regex: 'SAGEM ([a-z0-9]+)'
      model: '$1'
    - regex: 'SAGEM-([a-z0-9\-]+)'
      model: '$1'
    - regex: 'portalmmm/2.0 ((?:SG|my)[a-z0-9]+)'
      model: '$1'

# Coby Kyros
Coby Kyros:
  regex: '(MID(?:1024|1125|1126|1045|1048|1060|1065|4331|7012|7015A?|7016|7022|7032|7035|7036|7042|7047|7048|7052|7065|7120|8024|8042|8048|8065|8125|8127|8128|9724|9740|9742))[);/ ]'
  device: 'tablet'
  model: '$1'

# Mpman
Mpman:
  regex: '(?:MPQC|MPDC)[0-9]+|PH(?:150|340|350|360|451|500|520)|(?:MID(?:7C|74C|82C|84C|801|811|701|711|170|77C|43C|102C|103C|104C|114C)|MP(?:843|717|718|1010|7007|7008|843|888|959|969)|MGP7)[);/ ]'
  device: 'tablet'
  models:
    - regex: '((?:MPQC|MPDC)[0-9]+[^/;]+) Build'
      model: '$1'
    - regex: '(MID(?:7C|74C|82C|84C|801|811|701|711|170|77C|43C|102C|103C|104C|114C)|MP(?:843|717|718|1010|7007|7008|843|888|959|969)|MGP7)[);/ ]'
      model: '$1'
    - regex: '(PH(?:150|340|350|360|451|500|520))'
      model: '$1'
      device: 'smartphone'

# Majestic
Majestic:
  regex: 'MAJESTIC[ _-]|CRONO ?[0-9]+'
  device: 'smartphone'
  models:
      - regex: 'MAJESTIC[ _]Tab([^;/]+)Build'
        model: 'Tab$1'
        device: 'tablet'
      - regex: 'MAJESTIC[ _]Tab([^);/]+)[);/]'
        model: 'Tab$1'
        device: 'tablet'
      - regex: 'MAJESTIC[ _]([^;/]+)Build'
        model: '$1'
      - regex: 'MAJESTIC[ _]([^);/]+)[);/]'
        model: '$1'
      - regex: 'CRONO ?([0-9]+) Build'
        model: 'Crono $1'
      - regex: 'CRONO ?([0-9]+)[);/]'
        model: 'Crono $1'

# Manta Multimedia
Manta Multimedia:
  regex: '(MID(?:06[SN]|08[S]?|12|13|14|15|701|702|703|704|705(?:DC)?|706[AS]?|707|708|709|711|712|714|717|781|801|802|1001|1002|1003|1004(?: 3G)?|1005|7802|9701|9702))[);/ ]'
  device: 'tablet'
  model: '$1'

# Mediacom
Mediacom:
  regex: '(?:SmartPad7503G|SmartPad970s2(?:3G)?|M[_-][MP]P[0-9a-z]+|M-IPRO[0-9a-z]+)[);/ ]'
  device: 'tablet'
  models:
    - regex: 'SmartPad7503G[);/ ]'
      model: 'SmartPad 750 3G'
    - regex: 'SmartPad970s23G[);/ ]'
      model: 'SmartPad 970 S2 3G'
    - regex: 'SmartPad970s2[);/ ]'
      model: 'SmartPad 970 S2'
    - regex: 'M-MP84[02]M[);/ ]'
      model: 'SmartPad 8.0 Mobile'
    - regex: 'M-MP940M[);/ ]'
      model: 'SmartPad 9.7 Mobile'
    - regex: 'M-MP(?:710|720|725|726|740)GOx?[);/ ]'
      model: 'SmartPad 7.0 Go'
    - regex: 'M-MP876S2[);/ ]'
      model: 'SmartPad 8.0 S2'
    - regex: 'M-MP8S2[AB]?3G[);/ ]'
      model: 'SmartPad 8.0 S2 3G'
    - regex: 'M-MP(101|102|860|875)S2[BW]?[);/ ]'
      model: 'SmartPad $1 S2'
    - regex: 'M-MP85S23G[);/ ]'
      model: 'SmartPad 875 S2 3G'
    - regex: 'M-MP10[45][01]S2[);/ ]'
      model: 'SmartPad 10.1 S2'
    - regex: 'M-MP1S2[AB]3G[);/ ]'
      model: 'SmartPad 10.1 S2 3G'
    - regex: 'M-MP8[24]S4[);/ ]'
      model: 'SmartPad 8.0 S4'
    - regex: 'M-MP8S4[AB]3G[);/ ]'
      model: 'SmartPad 8.0 S4 3G'
    - regex: 'M-MP9S4A3G[);/ ]'
      model: 'SmartPad 9.7 S4 3G'
    - regex: 'M-MP1[02]S4[);/ ]'
      model: 'SmartPad 10.1 S4'
    - regex: 'M-MP1040MC?[);/ ]'
      model: 'SmartPad 10.1 HD S4 3G'
    - regex: 'M-MP1S4[AB]3G[);/ ]'
      model: 'SmartPad 10.1 S4 3G'
    - regex: 'M-MP8PA3G[);/ ]'
      model: 'SmartPad 8.0 HD Pro 3G'
    - regex: 'M-MP10PA[);/ ]'
      model: 'SmartPad 10.1 HD Pro'
    - regex: 'M-MP10PA3G[);/ ]'
      model: 'SmartPad 10.1 HD Pro 3G'
    - regex: 'M-IPRO([18][01]0)[BW][);/ ]'
      model: 'SmartPad 8.0 HD iPro$1 3G'

    - regex: '(?:M-MP75S23G|M-MP72[01]M)[);/ ]'
      model: 'SmartPad 7.0 Mobile'
      device: 'phablet'
    - regex: 'M-MP7S2[ABDK]3G[);/ ]'
      model: 'SmartPad 7.0 S2 3G'
      device: 'phablet'
    - regex: 'M-MP5303G[);/ ]'
      model: 'SmartPad Mini Mobile'
      device: 'phablet'
    - regex: 'M-PPAG550[);/ ]'
      model: 'PhonePad Duo G550'
      device: 'phablet'
    - regex: 'M-PP2G530[);/ ]'
      model: 'PhonePad Duo G530'
      device: 'phablet'
    - regex: 'M-PPG700[);/ ]'
      model: 'PhonePad Duo G700'
      device: 'phablet'
    - regex: 'M-PPxS531[);/ ]'
      model: 'PhonePad Duo S531'
      device: 'phablet'
    - regex: 'M-PP2S550[);/ ]'
      model: 'PhonePad Duo S550'
      device: 'phablet'
    - regex: 'M-PP2S650C?[);/ ]'
      model: 'PhonePad Duo S650'
      device: 'phablet'
    - regex: 'M-PPxS551U[);/ ]'
      model: 'PhonePad Duo S551U'
      device: 'phablet'

    - regex: 'M-PP[ABC]G500[);/ ]'
      model: 'PhonePad Duo G500'
      device: 'smartphone'
    - regex: 'M-PP2S500[BC]?[);/ ]'
      model: 'PhonePad Duo S500'
      device: 'smartphone'
    - regex: 'M[_-]PP[Ax]X(470|510|520)U[);/ ]'
      model: 'PhonePad Duo X$1U'
      device: 'smartphone'
    - regex: 'M-PPxG(400|501)[);/ ]'
      model: 'PhonePad Duo G$1'
      device: 'smartphone'
    - regex: 'M-PPxS(470|501)[);/ ]'
      model: 'PhonePad Duo S$1'
      device: 'smartphone'

    - regex: 'M-MP([0-9a-z]+)'
      model: 'SmartPad $1'

# Medion
Medion:
  regex: 'Medion|(?:MD_)?LIFETAB'
  device: 'smartphone'
  models:
    - regex: '(?:MD_)?LIFETAB_([a-z0-9]+)'
      device: 'tablet'
      model: 'Lifetab $1'
    - regex: 'Medion(?: Smartphone)? ([^/;]+) Build'
      model: '$1'

# MEEG
MEEG:
  regex: 'MEEG[ _-]'
  device: 'smartphone'
  models:
    - regex: 'MEEG[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'MEEG[ _\-]?([^);/ ]+)'
      model: '$1'

# Meizu
Meizu:
  regex: '(M04[05]|M35[1356]|MX[ -]?[234](?: Pro)?|(?:MZ-)?m[12] note|(?:MZ-)?M57[18]C)[);/ ]'
  device: 'smartphone'
  models:
    - regex: '(?:MZ-)?M571C'
      device: 'phablet'
      model: 'M2 Note'
    - regex: '(?:MZ-)?m(1|2) note[);/ ]'
      device: 'phablet'
      model: 'M$1 Note'
    - regex: '(?:MZ-)?M578C'
      model: 'M2'
    - regex: '(M04[05]|MX[ -]?2)[);/ ]'
      model: 'MX2'
    - regex: '(M35[1356]|MX[ -]?3)[);/ ]'
      model: 'MX3'
    - regex: 'MX[ -]?4 Pro[);/ ]'
      model: 'MX4 Pro'
    - regex: 'MX[ -]?4[);/ ]'
      model: 'MX4'

# Memup
Memup:
  regex: 'SlidePad ?([^;/]*) Build|SPNG?[0-9]{2,4}[a-z]{0,2}[ ;/)]|SP704CE?'
  device: 'tablet'
  models:
    - regex: 'SlidePad ?([^;/]*) Build'
      model: 'SlidePad $1'
    - regex: 'SPNG([0-9]{2,4}[a-z]{0,2})[ ;/)]'
      model: 'SlidePad NG$1'
    - regex: 'SP704(CE?)'
      model: 'SlidePad 704$1'

# Mecer
Mecer:
  regex: '(M785|800P3[12]C|101P51C|X1010)[);/ ]'
  device: 'tablet'
  models:
    - regex: 'M785[);/ ]'
      model: 'Xpress Smartlife M785'
    - regex: 'X1010[);/ ]'
      model: 'X1010'
    - regex: '800P31C[);/ ]'
      model: 'Xpress Smartlife 800P31C'
    - regex: '800P32C[);/ ]'
      model: 'Xpress Smartlife 800P32C'
    - regex: '101P51C[);/ ]'
      model: 'Xpress Smartlife 101P51C'

# mio
Mio:
  regex: 'MIO(?:/)?([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# mitsubishi
Mitsubishi:
  regex: 'MITSU|portalmmm/[12]\.0 M'
  device: 'feature phone'
  models:
    - regex: 'MITSU/[a-z0-9.]+ \(([a-z0-9]+)\)'
      model: '$1'
    - regex: 'MITSU[ \-]?([a-z0-9]+)'
      model: '$1'
    - regex: 'portalmmm/[12]\.0 (M[a-z0-9]+)'
      model: '$1'

# MSI
MSI:
  regex: 'Primo ?(?:91|76)|Enjoy 7 Plus'
  device: 'tablet'
  models:
    # explicit tablet models
    - regex: 'Primo ?76'
      model: 'Primo 76'
    - regex: 'Primo ?91'
      model: 'Primo 91'
    - regex: 'Enjoy 7 Plus'
      model: 'Enjoy 7 Plus'

# MLLED
MLLED:
  regex: 'MLLED[ _]'
  device: 'smartphone'
  models:
    - regex: 'MLLED[ _]([^;/]+)Build'
      model: '$1'
    - regex: 'MLLED[ _]([^);/]+)[);/]'
      model: '$1'

# Mobistel
Mobistel:
  regex: '(Cynus [^/;]+) Build'
  device: 'smartphone'
  model: '$1'


# Mofut
Mofut:
  regex: 'Mofut'
  device: 'smartphone'
  models:
    - regex: 'Mofut[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'Mofut[ _\-]?((?!Build)[^);/ ]+)'
      model: '$1'

# motorola
Motorola:
  regex: 'MOT|(?<!AN)DROID ?(?:Build|[a-z0-9]+)|portalmmm/2.0 (?:E378i|L6|L7|v3)|XOOM [^;/]*Build|(?:XT|MZ|MB|ME)[0-9]{3,4}[a-z]?(?:\(Defy\))?(?: Build|\))'
  device: 'smartphone'
  models:
    # Explicit feature phone models
    - regex: 'MOT-V360'
      model: 'V360'
      device: 'feature phone'

    # Explicit smartphone models
    - regex: '(?:MOT-|Motorola-)?XT300'
      model: 'Spice'
    - regex: '(?:MOT-|Motorola-)?XT30[35]'
      model: 'Motosmart ME'
    - regex: '(?:MOT-|Motorola-)?XT31[16]'
      model: 'Fire'
    - regex: '(?:MOT-|Motorola-)?XT32[01]'
      model: 'Defy Mini'
    - regex: '(?:MOT-|Motorola-)?XT3(?:89|90)'
      model: 'Motosmart'
    - regex: '(?:MOT-|Motorola-)?XT502'
      model: 'Quench'
    - regex: '(?:MOT-|Motorola-)?XT531'
      model: 'Fire XT'
    - regex: '(?:MOT-|Motorola-)?XT535'
      model: 'Defy'
    - regex: '(?:MOT-|Motorola-)?XT55[567]C?'
      model: 'Defy XT'
    - regex: '(?:MOT-|Motorola-)?XT603'
      model: 'Admiral'
    - regex: '(?:MOT-|Motorola-)?XT610'
      model: 'Droid Pro'
    - regex: '(?:MOT-|Motorola-)?XT615'
      model: 'Motoluxe'
    - regex: '(?:MOT-|Motorola-)?XT621'
      model: 'Primus'
    - regex: '(?:MOT-|Motorola-)?XT626'
      model: 'IronRock'
    - regex: '(?:MOT-|Motorola-)?XT682'
      model: 'Atrix'
    - regex: '(?:MOT-|Motorola-)?XT685'
      model: 'Motoluxe Dual-SIM'
    - regex: '(?:MOT-|Motorola-)?XT687'
      model: 'Atrix TV'
    - regex: '(?:MOT-|Motorola-)?XT720'
      model: 'Milestone'
    - regex: '(?:MOT-|Motorola-)?XT800W'
      model: 'Glam'
    - regex: '(?:MOT-|Motorola-)?XT860'
      model: 'Milestone 3'
    - regex: '(?:MOT-|Motorola-)?XT881'
      model: 'Electrify 2'
    - regex: '(?:MOT-|Motorola-)?XT882'
      model: 'Moto XT882'
    - regex: '(?:MOT-|Motorola-)?XT88[56]'
      model: 'Droid RAZR V'
    - regex: '(?:MOT-|Motorola-)?XT890'
      model: 'Droid RAZR i'
    - regex: '(?:MOT-|Motorola-)?XT894'
      model: 'Droid 4'
    - regex: '(?:MOT-|Motorola-)?XT897'
      model: 'Photon Q'
    - regex: '(?:MOT-|Motorola-)?XT901'
      model: 'Electrify M'
    - regex: '(?:MOT-|Motorola-)?XT90[567]'
      model: 'Droid RAZR M'
    - regex: '(?:MOT-|Motorola-)?XT910S?'
      model: 'Droid RAZR'
    - regex: '(?:MOT-|Motorola-)?XT91[4568]'
      model: 'Droid RAZR D1'
    - regex: '(?:MOT-|Motorola-)?XT9(?:19|20)'
      model: 'Droid RAZR D3'
    - regex: '(?:MOT-|Motorola-)?XT925'
      model: 'Droid RAZR HD'
    - regex: '(?:MOT-|Motorola-)?XT1022'
      model: 'Moto E'
    - regex: '(?:MOT-|Motorola-)?XT1030'
      model: 'Droid Mini'
    - regex: '(?:MOT-|Motorola-)?XT10(?:28|3[1234])'
      model: 'Moto G'
    - regex: '(?:MOT-|Motorola-)?XT10(?:49|5[23568]|60)'
      model: 'Moto X'
    - regex: '(?:MOT-|Motorola-)?XT1080'
      model: 'Droid Ultra'

    - regex: 'Motorola[ _\-]([a-z0-9]+)'
      model: '$1'
    - regex: 'MOTORAZR[ _\-]([a-z0-9]+)'
      model: 'RAZR $1'
    - regex: 'MOTORIZR[ _\-]([a-z0-9]+)'
      model: 'RIZR $1'
    - regex: 'MOT[O]?[_\-]?([a-z0-9.]+)'
      model: '$1'
    - regex: '(?<!AN)DROID ?([a-z0-9 ]*) Build'
      model: 'DROID $1'
    - regex: '(?<!AN)DROID ?([a-z0-9]+)'
      model: 'DROID $1'
    - regex: 'portalmmm/2.0 ((?:E378i|L6|L7|V3)[a-z0-9]+)'
      model: '$1'
    - regex: '(XOOM [^;/]*)Build'
      device: 'tablet'
      model: '$1'
    - regex: '(MZ[0-9]{3})[);/ ]'
      device: 'tablet'
      model: '$1'
    - regex: '((?:ME|MB|XT)[0-9]{3,4}(?:\(Defy\))?)[);/ ]'
      model: '$1'

# myphone
MyPhone:
  regex: '(?:MyPhone|MyPad) [^;/]+ Build'
  device: 'smartphone'
  models:
    - regex: 'MyPad ([^;/]+) Build'
      model: 'MyPad $1'
      device: 'tablet'
    - regex: 'MyPhone ([^;/]+) Build'
      model: '$1'

# M.T.T.
M.T.T.:
  regex: 'M.T.T.'
  device: 'smartphone'
  models:
    - regex: 'M.T.T. ?Tablet([^;/]+)? Build'
      device: 'tablet'
      model: 'Tablet$1'
    - regex: 'M.T.T. ?([^;/]+) Build'
      model: '$1'

# nec
NEC:
  regex: 'NEC[ _\-]|KGT/2\.0|portalmmm/1\.0 (?:DB|N)|(?:portalmmm|o2imode)/2.0[ ,]N'
  device: 'smartphone'
  models:
    - regex: '(?:NEC[ _\-]|KGT/2\.0 )([a-z0-9]+)'
      model: '$1'
    - regex: 'portalmmm/1\.0 ((?:DB|N)[a-z0-9]+)'
      model: '$1'
    - regex: '(?:portalmmm|o2imode)/2\.0[ ,](N[a-z0-9]+)'
      model: '$1'

# newgen
Newgen:
  regex: 'NEWGEN\-([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Netgear
Netgear:
  regex: 'GTV100'
  device: 'tv'
  models:
   - regex: 'GTV100'
     model: 'NeoTV Prime'

# NextBook
NextBook:
  regex: 'Next[0-9]|NX785QC8G|NXM900MC|NX008HD8G|NX010HI8G|NXM908HC'
  device: 'tablet'
  models:
    - regex: 'NX008HD8G'
      model: 'Premium 8 HD'
    - regex: 'NXM908HC'
      model: 'Premium 9'
    - regex: 'NX010HI8G'
      model: 'Premium 10 Hi'
    - regex: 'NX785QC8G'
      model: '8'
    - regex: 'NXM900MC'
      model: '8 HD'

    - regex: 'Next([0-9]+[^;/]+) Build'
      model: 'Next $1'

# ngm
NGM:
  regex: 'NGM[_ ][a-z0-9]+|(Forward|Dynamic)[ _]?[^/;]+(?:Build|/)'
  device: 'smartphone'
  models:
    - regex: '(Forward|Dynamic)[ _]?([^/;]+) Build'
      model: '$1 $2'
    - regex: '(Forward|Dynamic)[ _]?([^/;]+)/'
      model: '$1 $2'
    - regex: 'NGM ([^;/]+) Build'
      model: '$1'
    - regex: 'NGM_([a-z0-9]+)'
      model: '$1'

# nexian
Nexian:
  regex: 'S?Nexian'
  device: 'smartphone'
  models:
    - regex: 'S?Nexian[ ]?([a-z0-9\-]+)'
      model: '$1'
    - regex: 'S?Nexian-([a-z0-9]+)'
      model: '$1'

# Noain
Noain:
  regex: 'NOAIN'
  device: 'smartphone'
  models:
    - regex: 'NOAIN[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'NOAIN[ _-]([^;/)]+)[;/)]'
      model: '$1'

# Nomi
Nomi:
  regex: 'Nomi[ _-]'
  device: 'smartphone'
  models:
    - regex: 'Nomi[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Nomi[ _-]([^;/)]+)[;/)]'
      model: '$1'

# o2
O2:
  regex: 'Xda|O2[ \-]|COCOON'
  device: 'smartphone'
  models:
    - regex: '(Xda[ _][a-z0-9_]+)'
      model: '$1'
    - regex: '(COCOON)'
      model: '$1'
    - regex: 'O2 ([a-z0-9 ]+)'
      model: '$1'
    - regex: 'O2-([a-z0-9]+)'
      model: '$1'

# onda
Onda:
  regex: 'Onda'
  device: 'smartphone'
  models:
    # explicit tablet models
    - regex: 'ONDA MID'
      model: 'MID'
      device: 'tablet'

    - regex: '([a-z0-9]+)[ _]Onda'
      model: '$1'
    - regex: 'Onda ([a-z0-9]+)'
      model: '$1'

# oppo
OPPO:
  regex: '(?:OB-)?OPPO[ _]?([a-z0-9]+)|N1T|(?:X90[07][067]|U707T?|X909T?|R(?:10[01]1|2001|201[07]|6007|7005|7007|80[13579]|81[13579]|82[01379]|83[013]|800[067]|8015|810[679]|811[13]|820[057])[KLSTW]?)|N520[79]|N5117[);/ ]'
  device: 'smartphone'
  models:
    - regex: 'U707T?[);/ ]'
      model: 'Find Way S'
    - regex: 'X909T?[);/ ]'
      model: 'Find 5'
    - regex: 'X907[067][);/ ]'
      model: 'Find 7'
    - regex: 'X900[067][);/ ]'
      model: 'Find 7a'
    - regex: 'R8006[);/ ]'
      model: 'R1L'
    - regex: 'R800[07][);/ ]'
      model: 'R1S'
    - regex: 'R8015[);/ ]'
      model: 'Find Guitar'
    - regex: 'R810[679][);/ ]'
      model: 'R5'
    - regex: 'R8111[);/ ]'
      model: 'Find Melody'
    - regex: 'R8113[);/ ]'
      model: 'Piano'
    - regex: 'R815[TW]?[);/ ]'
      model: 'Find Clover'
    - regex: 'R821T?[);/ ]'
      model: 'Find Muse'
    - regex: 'R827T?[);/ ]'
      model: 'Find 5 Mini'
    - regex: 'R831[SL][);/ ]'
      model: 'Neo 5'
    - regex: 'R831K[);/ ]'
      model: 'Neo 3'
    - regex: 'R831T?[);/ ]'
      model: 'Neo'
    - regex: 'N520[79][);/ ]'
      model: 'N3'
    - regex: 'N5117[);/ ]'
      model: 'N1 Mini'

    - regex: 'N1T?[);/ ]'
      model: 'N1T'
      device: 'phablet'

    - regex: 'R([0-9]{3,4}[KSTW]?)[);/ ]' # valid model numbers are filtered in main regex
      model: 'R$1'

    - regex: '(?:OB-)?OPPO[ _]?([a-z0-9]+)'
      model: '$1'

# Opsson
Opsson:
  regex: 'Opsson|IUSAI'
  device: 'smartphone'
  models:
    - regex: 'IUSAI[ _]([^/;]+) Build'
      model: 'Iusai $1'
    - regex: 'IUSAI[ _]([^/;\)]+)[/;\)]'
      model: 'Iusai $1'
    - regex: 'Opsson[ _]([^/;]+) Build'
      model: '$1'
    - regex: '(?:Opsson-)?Opsson[ -_]([^/;]+)/'
      model: '$1'

# orange
Orange:
  regex: 'SPV[ \-]?([a-z0-9]+)|Orange ([^/;]+) Build|SC/IHD92'
  device: 'smartphone'
  models:
    - regex: 'Orange ([^/;]+) Build'
      model: '$1'
    - regex: 'SPV[ \-]?([a-z0-9]+)'
      model: 'SPV $1'
    - regex: 'SC/IHD92'
      model: 'Livebox Play'
      device: 'tv' # set top box

# Ouki
Ouki:
  regex: 'OUKI|OK[AU][0-9]+[a-z]* Build'
  device: 'smartphone'
  models:
    - regex: 'OUKI[ _-]?([^;/]+) Build'
      model: '$1'
    - regex: '([^;/)]+) Build/OUKI'
      model: '$1'
    - regex: 'OUKI[ _-]?([^;/)]+)[;/)]'
      model: '$1'
    - regex: '(OK[AU][0-9]+[a-z]*) Build'
      model: '$1'

# Overmax
Overmax:
  regex: 'OV-[a-z]+(?:[^;/]+)? Build'
  device: 'tablet'
  models:
    - regex: 'OV-Vertis-([^;/]+) Build'
      model: 'OV-Vertis-$1'
      device: 'smartphone'

    - regex: '(OV-[a-z]+(?:[^;/]+)?) Build'
      model: '$1'

# Oysters
Oysters:
  regex: 'Oysters'
  device: 'tablet'
  models:
    - regex: 'Oysters ((?:Arctic|Indian|Atlantic|Pacific)[^/;]+) Build'
      device: 'smartphone'
      model: '$1'
    - regex: 'Oysters ([^/;]+) Build'
      model: '$1'

# panasonic
Panasonic:
  regex: 'Panasonic|PANATV[0-9]+|Viera/'
  device: 'smartphone'
  models:
    - regex: 'Panasonic MIL DLNA'
      device: 'tv'
      model: 'Viera Cast'
    - regex: 'PANATV[0-9]+|Viera/'
      device: 'tv'
      model: 'Smart TV'
    - regex: 'Panasonic[ \-]?([a-z0-9]+)'
      model: '$1'
    - regex: 'portalmmm/2.0 (P[a-z0-9]+)'
      model: '$1'

# philips
Philips:
  regex: 'Philips|AND1E[);/ ]|NETTV/'
  device: 'smartphone'
  models:
    - regex: 'AND1E(?: TV)?[);/ ]'
      model: 'Android TV'
      device: 'tv'
    - regex: 'Philips, BDP([0-9]{4})'
      model: 'Blu-ray Player (BDP$1)'
      device: 'tv'
    - regex: '(NETTV/[0-9\.]{5})'
      model: 'NetTV Series'
      device: 'tv'
    - regex: 'Philips-FISIO ([a-z0-9]+)'
      model: 'Fisio $1'
    - regex: 'Philips[ ]?([a-z0-9]+)'
      model: '$1'
    - regex: 'Philips-([a-z0-9\-@]+)'
      model: '$1'

# phoneOne
phoneOne:
  regex: 'phoneOne[ \-]?([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# PULID
PULID:
  regex: 'PULID[ _]|F1[01357]\+? Build'
  device: 'smartphone'
  models:
    - regex: 'F(1[01357]\+?) Build'
      model: 'F$1'
    - regex: 'PULID[ _]([^;/]+) Build'
      model: '$1'
    - regex: 'PULID[ _]([a-z0-9_]+)\)'
      model: '$1'

# Point of View
'Point of View':
  regex: 'POV_TV|POV_TAB|MOB-5045'
  device: 'tablet'
  models:
    - regex: 'POV_TV-HDMI-KB-01'
      model: 'HDMI Smart TV Dongle'
      device: 'tv'
    - regex: 'POV_TV-HDMI-200BT'
      model: 'Mini PC HDMI Dongle'
      device: 'tv'
    - regex: 'MOB-5045'
      model: 'Mobii Phone 5045'
      device: 'smartphone'
    - regex: 'POV_TAB-P506'
      model: 'ONYX 506 Navi'
    - regex: 'POV_TAB[_-]NAVI7[_-]3G[_-]M'
      model: 'ONYX 507 Navi'
    - regex: 'POV_TAB-P527S'
      model: 'ONYX 527S'
    - regex: 'POV_TAB-P547'
      model: 'ONYX 547 Navi'
    - regex: 'POV_TAB-PROTAB26'
      model: 'ProTab 26 XXL IPS'
    - regex: 'POV_TAB-PROTAB25XXL8?'
      model: 'ProTab 25XXL'
    - regex: 'POV_TAB-PL1015'
      model: 'Mobii 1015'

    - regex: 'POV_TAB-PROTAB([a-z0-9]+)'
      model: 'ProTab $1'
    - regex: 'POV_TAB-P?([a-z0-9]+)'
      model: 'Mobii $1'

# Pomp
Pomp:
  regex: 'POMP[ _-]'
  device: 'smartphone'
  models:
    - regex: 'POMP[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'POMP[ _-]([^;/)]+)[;/)]'
      model: '$1'

# ProScan
ProScan:
  regex: 'PLT([^;/]+) Build'
  device: 'tablet'
  model: 'PLT$1'

# RCA Tablets
'RCA Tablets':
  regex: 'RCT([^;/]+) Build'
  device: 'tablet'
  model: 'RCT$1'

# Readboy
Readboy:
  regex: 'Readboy[ _-]'
  device: 'tablet'
  models:
    - regex: 'Readboy[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Readboy[ _-]([^;/]+)[;/)]'
      model: '$1'

# Roku
Roku:
  regex: 'Roku/DVP'
  device: 'tv'
  model: 'Digital Video Player'

# Rover
Rover:
  regex: 'Rover ([0-9]+)'
  device: 'feature phone'
  model: '$1'

# Siemens
Siemens:
  regex: 'SIEMENS|SIE-|portalmmm/2\.0 SI|S55|SL45i'
  device: 'smartphone'
  models:
    - regex: 'SIEMENS[ \-]([a-z0-9]+)'
      model: '$1'
    - regex: 'SIE(?:MENS )?[\-]?([a-z0-9]+)'
      model: '$1'
    - regex: '(S55|SL45i)'
      model: '$1'
    - regex: 'portalmmm/2.0 (SI[a-z0-9]+)'
      model: '$1'

# Samsung
Samsung:
  regex: 'SAMSUNG|Maple |SC-(?:02C|04E|01F)|N[57]100|N5110|N9100|S(?:CH|GH|PH|EC|AM|HV|HW|M)-|SMART-TV|GT-|Galaxy|(?:portalmmm|o2imode)/2\.0 [SZ]|sam[rua]|vollo Vi86[);/ ]|(?:OTV-)?SMT-E5015'
  device: 'smartphone'
  models:
    # explicit tv models
    - regex: 'GT-B9150'
      device: 'tv'
      model: 'Home Sync'
    - regex: '(?:OTV-)?SMT-E5015'
      device: 'tv'
      model: 'SMT-E5015' # set top box
    - regex: 'Maple '
      device: 'tv'
      model: ''

    # explicit tablet models
    - regex: '(?:SAMSUNG-)?(?:GT-)?N5100'
      device: 'tablet'
      model: 'GALAXY Note 8.0"'
    - regex: '(?:SAMSUNG-)?(?:GT-)?N5110'
      device: 'tablet'
      model: 'GALAXY Note 8.0" WiFi'
    - regex: '(?:SAMSUNG-)?GT-N5120'
      device: 'tablet'
      model: 'GALAXY Note 8.0" LTE'
    - regex: '(?:SAMSUNG-)?GT-N8000'
      device: 'tablet'
      model: 'GALAXY Note 10.1"'
    - regex: '(?:SAMSUNG-)?GT-N8010'
      device: 'tablet'
      model: 'GALAXY Note 10.1" WiFi'
    - regex: '(?:SAMSUNG-)?GT-N8020'
      device: 'tablet'
      model: 'GALAXY Note 10.1" LTE'
    - regex: '(?:SAMSUNG-)?GT-P1000M?|SCH-I800'
      device: 'tablet'
      model: 'GALAXY Tab'
    - regex: '(?:SAMSUNG-)?GT-P3100B?'
      device: 'tablet'
      model: 'GALAXY Tab 2 7"'
    - regex: '(?:SAMSUNG-)?GT-P311[03]'
      device: 'tablet'
      model: 'GALAXY Tab 2 7" WiFi'
    - regex: '(?:SAMSUNG-)?GT-P5100|SCH-I915'
      device: 'tablet'
      model: 'GALAXY Tab 2 10.1"'
    - regex: '(?:SAMSUNG-)?GT-P511[03]'
      device: 'tablet'
      model: 'GALAXY Tab 2 10.1" WiFi'
    - regex: '(?:SAMSUNG-)?GT-P5200'
      device: 'tablet'
      model: 'GALAXY Tab 3 10.1"'
    - regex: '(?:SAMSUNG-)?GT-P5210'
      device: 'tablet'
      model: 'GALAXY Tab 3 10.1" WiFi'
    - regex: '(?:SAMSUNG-)?GT-P5220'
      device: 'tablet'
      model: 'GALAXY Tab 3 10.1" LTE'
    - regex: '(?:SAMSUNG-)?GT-P6200'
      device: 'tablet'
      model: 'GALAXY Tab 7" Plus'
    - regex: '(?:SAMSUNG-)?GT-P6201'
      device: 'tablet'
      model: 'GALAXY Tab 7" Plus N'
    - regex: '(?:SAMSUNG-)?GT-P6810'
      device: 'tablet'
      model: 'GALAXY Tab 7.7"'
    - regex: '(?:SAMSUNG-)?GT-P7100'
      device: 'tablet'
      model: 'GALAXY Tab 10.1v'
    - regex: '(?:SAMSUNG-)?GT-P7500'
      device: 'tablet'
      model: 'GALAXY Tab 10.1" P7500'
    - regex: '(?:SAMSUNG-)?SM-P600'
      device: 'tablet'
      model: 'GALAXY Note 10.1" 2014 Edition WiFi'
    - regex: '(?:SAMSUNG-)?SM-P60[12]'
      device: 'tablet'
      model: 'GALAXY Note 10.1" 2014 Edition'
    - regex: '(?:SAMSUNG-)?SM-P605'
      device: 'tablet'
      model: 'GALAXY Note 10.1" 2014 Edition LTE'
    - regex: '(?:SAMSUNG-)?SM-P900'
      device: 'tablet'
      model: 'GALAXY NotePRO 12.2" WiFi'
    - regex: '(?:SAMSUNG-)?SM-P901'
      device: 'tablet'
      model: 'GALAXY NotePRO 12.2"'
    - regex: '(?:SAMSUNG-)?SM-P905'
      device: 'tablet'
      model: 'GALAXY NotePRO 12.2" LTE'
    - regex: '(?:SAMSUNG-)?SM-T110'
      device: 'tablet'
      model: 'GALAXY Tab 3 7.0" Lite WiFi'
    - regex: '(?:SAMSUNG-)?SM-T111'
      device: 'tablet'
      model: 'GALAXY Tab 3 7.0" Lite'
    - regex: '(?:SAMSUNG-)?SM-T2105'
      device: 'tablet'
      model: 'GALAXY Tab 3 7.0" Kids'
    - regex: '(?:SAMSUNG-)?SM-T210R?'
      device: 'tablet'
      model: 'GALAXY Tab 3 7.0" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T21(?:1|7[AS])'
      device: 'tablet'
      model: 'GALAXY Tab 3 7.0"'
    - regex: '(?:SAMSUNG-)?SM-T230(?:NU)?'
      device: 'tablet'
      model: 'GALAXY Tab 4 7.0" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T310'
      device: 'tablet'
      model: 'GALAXY Tab 3 8.0" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T311'
      device: 'tablet'
      model: 'GALAXY Tab 3 8.0"'
    - regex: '(?:SAMSUNG-)?SM-T315'
      device: 'tablet'
      model: 'GALAXY Tab 3 8.0" LTE'
    - regex: '(?:SAMSUNG-)?SM-T335'
      device: 'tablet'
      model: 'GALAXY Tab 8.0" LTE'
    - regex: '(?:SAMSUNG-)?SM-T520'
      device: 'tablet'
      model: 'GALAXY TabPRO 10.1" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T535'
      device: 'tablet'
      model: 'GALAXY Tab 4 10.1" LTE'
    - regex: '(?:SAMSUNG-)?SM-T320'
      device: 'tablet'
      model: 'GALAXY TabPRO 8.4" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T325'
      device: 'tablet'
      model: 'GALAXY TabPRO 8.4" LTE'
    - regex: '(?:SAMSUNG-)?SM-T525'
      device: 'tablet'
      model: 'GALAXY TabPRO 10.1" LTE'
    - regex: '(?:SAMSUNG-)?SM-T530(?:NU)?'
      device: 'tablet'
      model: 'GALAXY Tab 4 10.1" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T700'
      device: 'tablet'
      model: 'GALAXY Tab S 8.4" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T705'
      device: 'tablet'
      model: 'GALAXY Tab S 8.4" LTE'
    - regex: '(?:SAMSUNG-)?SM-T800'
      device: 'tablet'
      model: 'GALAXY Tab S 10.5" WiFi'
    - regex: '(?:SAMSUNG-)?SM-T805'
      device: 'tablet'
      model: 'GALAXY Tab S 10.5" LTE'
    - regex: '(?:SAMSUNG-)?SM-T900'
      device: 'tablet'
      model: 'GALAXY TabPRO 12.2" WiFi'

    # explicit smartphone models
    - regex: '(?:SAMSUNG-)?GT-B5330'
      model: 'GALAXY Chat'
    - regex: '(?:SAMSUNG-)?GT-B5510'
      model: 'GALAXY Y Pro'
    - regex: '(?:SAMSUNG-)?GT-B5512'
      model: 'GALAXY Y Pro Duos'
    - regex: '(?:SAMSUNG-)?GT-B7510'
      model: 'GALAXY Pro'
    - regex: '(?:SAMSUNG-)?GT-I5700'
      model: 'GALAXY Spica'
    - regex: '(?:SAMSUNG-)?GT-I5801'
      model: 'GALAXY Apollo'
    - regex: '(?:SAMSUNG-)?GT-I5800'
      model: 'GALAXY 3'
    - regex: '(?:SAMSUNG-)?GT-I8000'
      model: 'Omnia II'
    - regex: '(?:SAMSUNG-)?GT-I8150'
      model: 'GALAXY W'
    - regex: '(?:SAMSUNG-)?GT-I8160'
      model: 'GALAXY Ace 2'
    - regex: '(?:SAMSUNG-)?GT-I8190'
      model: 'GALAXY S III mini'
    - regex: '(?:SAMSUNG-)?GT-I8200'
      model: 'GALAXY S III mini Value Edition'
    - regex: '(?:SAMSUNG-)?GT-I826[02]'
      model: 'GALAXY Core'
    - regex: '(?:SAMSUNG-)?GT-I8320'
      model: 'H1'
    - regex: '(?:SAMSUNG-)?GT-I85[23]0'
      model: 'GALAXY Beam'
    - regex: '(?:SAMSUNG-)?GT-I855[028]'
      model: 'GALAXY Win'
    - regex: '(?:SAMSUNG-)?GT-I8580'
      model: 'GALAXY Core Advance'
    - regex: '(?:SAMSUNG-)?GT-I8730'
      model: 'GALAXY Express'
    - regex: '(?:SAMSUNG-)?GT-I90(?:00|08|18|88)'
      model: 'GALAXY S'
    - regex: '(?:SAMSUNG-)?GT-I9001'
      model: 'GALAXY S Plus'
    - regex: '(?:SAMSUNG-)?GT-I9003'
      model: 'GALAXY SL'
    - regex: '(?:SAMSUNG-)?GT-I9010'
      model: 'GALAXY S Giorgio Armani'
    - regex: '(?:SAMSUNG-)?GT-I9070'
      model: 'GALAXY S Advance'
    - regex: '(?:SAMSUNG-)?GT-I910[08]'
      model: 'GALAXY S II'
    - regex: '(?:SAMSUNG-)?GT-I9103'
      model: 'GALAXY R'
    - regex: '(?:SAMSUNG-)?GT-I9105'
      model: 'GALAXY S II Plus'
    - regex: '(?:SAMSUNG-)?(?:GT-I919[05]|SCH-I435)'
      model: 'GALAXY S4 mini'
    - regex: '(?:SAMSUNG-)?GT-I9295'
      model: 'GALAXY S4 ACTIVE'
    - regex: '(?:SAMSUNG-)?(?:GT-I9300|SCH-I535|SCH-L710)'
      model: 'GALAXY S III'
    - regex: '(?:SAMSUNG-)?(?:GT-I9305|SCH-R530)'
      model: 'GALAXY S III LTE'
    - regex: '(?:SAMSUNG-)?(?:GT-I9505|SCH-I545|SCH-I959|SCH-R970|GALAXY-S4)'
      model: 'GALAXY S4'
    - regex: '(?:SAMSUNG-)?GT-I9506'
      model: 'GALAXY S4 with LTE+'
    - regex: '(?:SAMSUNG-)?GT-S5280'
      model: 'GALAXY STAR'
    - regex: '(?:SAMSUNG-)?GT-S5301'
      model: 'GALAXY POCKET Plus'
    - regex: '(?:SAMSUNG-)?GT-S5310'
      model: 'GALAXY POCKET Neo'
    - regex: '(?:SAMSUNG-)?GT-S5360'
      model: 'GALAXY Y Hello Kitty'
    - regex: '(?:SAMSUNG-)?GT-S6310'
      model: 'GALAXY Young'
    - regex: '(?:SAMSUNG-)?GT-S6312'
      model: 'GALAXY Young DUOS'
    - regex: '(?:SAMSUNG-)?GT-S6790'
      model: 'GALAXY FAME Lite with NFC'
    - regex: '(?:SAMSUNG-)?GT-S6810'
      model: 'GALAXY FAME'
    - regex: '(?:SAMSUNG-)?GT-S7275'
      model: 'GALAXY ACE 3'
    - regex: '(?:SAMSUNG-)?GT-S7390'
      model: 'GALAXY Trend Lite'
    - regex: '(?:SAMSUNG-)?GT-S7500'
      model: 'GALAXY ACE Plus'
    - regex: '(?:SAMSUNG-)?(?:GT-S7560|SCH-I699)'
      model: 'GALAXY Trend'
    - regex: '(?:SAMSUNG-)?(?:GT-S7562|SCH-I919)'
      model: 'GALAXY S DUOS'
    - regex: '(?:SAMSUNG-)?GT-S7580'
      model: 'GALAXY Trend Plus'
    - regex: '(?:SAMSUNG-)?GT-S7582'
      model: 'GALAXY DUOS 2'
    - regex: '(?:SAMSUNG-)?GT-S7710'
      model: 'GALAXY Xcover 2'
    - regex: '(?:SAMSUNG-)?SM-C101'
      model: 'GALAXY S4 zoom'
    - regex: '(?:SAMSUNG-)?SM-C115'
      model: 'GALAXY K zoom'
    - regex: '(?:SAMSUNG-)?SM-G350'
      model: 'GALAXY CORE Plus'
    - regex: '(?:SAMSUNG-)?SM-G386F'
      model: 'GALAXY CORE LTE'
    - regex: '(?:SAMSUNG-)?SM-G3815'
      model: 'GALAXY EXPRESS II'
    - regex: '(?:SAMSUNG-)?SM-G800'
      model: 'GALAXY S5 mini'
    - regex: '(?:SAMSUNG-)?SM-G9009D'
      model: 'GALAXY S5 Dual-SIM'
    - regex: '(?:SAMSUNG-)?SM-G900|GALAXY-S5'
      model: 'GALAXY S5'
    - regex: '(?:SAMSUNG-)?SCH-I200'
      model: 'GALAXY Stellar'
    - regex: '(?:SAMSUNG-)?SCH-I829'
      model: 'GALAXY Style Duos'
    - regex: '(?:SAMSUNG-)?(?:SGH-S730|SCH-R740)'
      model: 'GALAXY Discover'
    - regex: '(?:SAMSUNG-)?SCH-S738'
      model: 'GALAXY Centura'
    - regex: 'vollo Vi86[);/ ]'
      model: 'Vollo Vi86'

    # explicit phablet models
    - regex: '(?:SAMSUNG-)?GT-I9060'
      model: 'GALAXY Grand Neo'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I9063'
      model: 'GALAXY Grand Neo Duos'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I9(?:080|128)'
      model: 'GALAXY Grand'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I9168'
      model: 'GALAXY Grand Neo+'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I9082'
      model: 'GALAXY Grand Duos'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?(?:(?:GT-)?N7100|SCH-I605|SCH-N719|SCH-R950|SPH-L900)'
      model: 'GALAXY Note II'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-N7105'
      model: 'GALAXY Note II LTE'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-G7105'
      model: 'GALAXY Grand 2'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N7502'
      model: 'GALAXY Note 3 Neo Duos'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N750[L50]?'
      model: 'GALAXY Note 3 Neo'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N9002'
      model: 'GALAXY Note 3 Duos'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N900(?:[05689][VQ]?|[AKLPSTV]|W8)?'
      model: 'GALAXY Note 3'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N910|N9100'
      model: 'GALAXY Note 4'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?SM-N915'
      model: 'GALAXY Note 4 Edge'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I915[028]'
      model: 'GALAXY Mega 5.8'
      device: 'phablet'
    - regex: '(?:SAMSUNG-)?GT-I920[05]'
      model: 'GALAXY Mega 6.3'
      device: 'phablet'

    # explicit feature phones
    - regex: '(?:SAMSUNG-)?GT-E2152'
      model: 'E2152'
      device: 'feature phone'

    # general detections
    - regex: '(?:SAMSUNG-)?(GT-(P|N8|N5)[0-9]+[a-z]?)'
      device: 'tablet'
      model: '$1'
    - regex: 'SC-02C'
      model: 'GALAXY S II'
    - regex: 'SC-01F'
      model: 'GALAXY Note 3'
      device: 'phablet'
    - regex: 'SC-04E'
      model: 'GALAXY S4'
    - regex: '(?:SAMSUNG-)?((?:SM-[TNP]|GT-P)[a-z0-9_\-]+)'
      device: 'tablet'
      model: '$1'
    - regex: '((?:SCH|SGH|SPH|SHV|SHW|GT|SM)-[a-z0-9_\-]+)'
      model: '$1'
    - regex: 'SMART-TV'
      device: 'tv'
      model: 'Smart TV'
    - regex: 'Galaxy ([^/;]+) Build'
      model: 'GALAXY $1'
    - regex: 'Galaxy ([a-z0-9]+)'
      model: 'GALAXY $1'
    - regex: 'SAMSUNG[\-][ ]?([a-z0-9]+[\-_][a-z0-9]+)'
      model: '$1'
    - regex: 'SAMSUNG;[ ]?([a-z0-9]+[\-_][a-z0-9]+)'
      model: '$1'
    - regex: 'SAMSUNG(?!Browser)[ _/\-]?([a-z0-9\-]+)'
      model: '$1'
    - regex: 'SAMSUNG;[ ]?([a-z0-9 ]+)'
      model: '$1'
    - regex: 'SEC-([a-z0-9]+)'
      model: '$1'
    - regex: 'SAM-([a-z0-9]+)'
      model: 'SCH-$1'
    - regex: '(?:portalmmm|o2imode)/2\.0 ([SZ][a-z0-9]+)'
      model: '$1'
    - regex: 'sam([rua][0-9]+)'
      model: 'SCH-$1'

# Sencor
Sencor:
  regex: 'Sencor|ELEMENT[ _]?(?:7|8|9\.7|10[ _]1)(?:[ _]?V[23])?[);/ ]|ELEMENT[ _]?(?:P[0-9]+)[);/ ]'
  device: 'tablet'
  models:
    # explicit tablet models
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]?7[ _]?V3'
      model: 'Element 7 V3'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]?7[ _]?V2[ _]BASIC'
      model: 'Element 7 V2 Basic'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]?7[ _]?V2'
      model: 'Element 7 V2'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]8[ _]?V3'
      model: 'Element 8 V3'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]8[ _]?V2'
      model: 'Element 8 V2'
    - regex: '(?:SENCOR[ _])?ELEMENT8'
      model: 'Element 8'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]9\.7[ _]?V3'
      model: 'Element 9.7 V3'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]9\.7[ _]?V2'
      model: 'Element 9.7 V2'
    - regex: '(?:SENCOR[ _])?ELEMENT[ _]9\.7'
      model: 'Element 9.7'
    - regex: '(?:SENCOR[ _])?ELEMENT10[ _]1'
      model: 'Element 10.1'

    - regex: '(?:SENCOR[ _])?ELEMENT[ _]?P([0-9]+)'
      model: 'Element P$1'
      device: 'smartphone'

    - regex: 'Sencor[ _]([^;/]+) Build'
      model: '$1'

# Skyworth
Skyworth:
  regex: 'Sky_?worth'
  device: 'tv'
  models:
    - regex: 'Sky_?worth ([^;/]+) Build'
      model: '$1'

# Smartfren
Smartfren:
  regex: 'Smartfren|Androtab|Andromax|PD6D1J|AD682J|AD68[89]G|AD6B1H|AD9A1H|AD682H|AD683G'
  device: 'smartphone'
  models:
    # explicit tablet models
    - regex: 'S7 Build'
      model: 'Andromax Tab 7.0'
      device: 'tablet'

    # explicit smartphone models
    - regex: 'PD6D1J'
      model: 'Andromax V3s'
    - regex: 'AD682J'
      model: 'Andromax T'
    - regex: 'AD688G'
      model: 'Andromax C2'
    - regex: 'AD689G'
      model: 'Andromax i3'
    - regex: 'AD682H'
      model: 'Andromax i3s'
    - regex: 'AD6B1H'
      model: 'Andromax G2 Hot'
    - regex: 'AD9A1H'
      model: 'Andromax G2'
    - regex: 'AD683G'
      model: 'Andromax I'
    - regex: 'New Andromax-i'
      model: 'New Andromax I'

    - regex: 'Andromax[ _\-]([^/;]+) Build'
      model: 'Andromax $1'
    - regex: 'Andromax[ _\-]([a-z0-9]+)'
      model: 'Andromax $1'
    - regex: 'Smartfren[ _\-]([^/;]+) Build'
      model: '$1'
    - regex: '(Androtab[^/;]+) Build'
      model: '$1'
      device: 'tablet'

# Stonex
Stonex:
  regex: 'STX[ -]([^;/]+)'
  device: 'smartphone'
  models:
    - regex: 'STX[ -]([^;/]+) Build'
      model: '$1'
    - regex: 'STX[ -]([a-z0-9_-]+)'
      model: '$1'

# SuperSonic
SuperSonic:
  regex: '(SC-[0-9]+[a-z]+)'
  device: 'tablet'
  model: '$1'

# Sumvision
Sumvision:
  regex: '(Cyclone [^/;]+) Build'
  device: 'tablet'
  model: '$1'

# SunVan
SunVan:
  regex: 'SUNVAN[ _\-]'
  device: 'smartphone'
  models:
    - regex: 'SUNVAN[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'SUNVAN[ _\-]?([^);/ ]+)'
      model: '$1'

# Thomson
Thomson:
  regex: '(?:Primo(7|8)|QM73[45]-8G|QM734-2|QM736-8G\(HD\)|8950|MID1002)[);/ ]|(?:Tlink|Every)[0-9]+'
  device: 'tablet'
  models:
    # already detected as manta device
    #- regex: 'MID1002'
    #  model: 'MID1002'
    - regex : 'Primo(7|8)'
      model: 'Primo $1'
    - regex: 'QM734-2'
      model: 'QM734-2'
    - regex: 'QM734-8G'
      model: 'QM734-8G'
    - regex: 'QM735-8G'
      model: 'QM735-8G'
    - regex: 'QM736-8G\(HD\)'
      model: 'QM736-8G (HD)'
    - regex: '8950 Build'
      model: '3G 8950'

    - regex: 'Tlink([0-9]+)'
      device: 'smartphone'
      model: 'Tlink$1'
    - regex: 'Every([0-9]+)'
      device: 'smartphone'
      model: 'Every$1'

# pantech
Pantech:
  regex: 'Pantech|P[GN]-|PT-[a-z0-9]{3,}|TX[T]?[0-9]+|IM-[a-z0-9]+[);/ ]|ADR910L'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'ADR910L'
      model: 'Star Q'

    - regex: 'Pantech[ \-]?([a-z0-9]+)'
      model: '$1'
    - regex: 'Pantech_([a-z0-9\-]+)'
      model: '$1'
    - regex: '(P[GTN]-[a-z0-9]+)'
      model: '$1'
    - regex: '(TX[T]?[0-9]+)'
      model: '$1'
    - regex: '(IM-[a-z0-9]+)[);/ ]'
      model: '$1'

# Polaroid
Polaroid:
  regex: 'Polaroid|(?:PMID|MIDC)[0-9a-z]+[);/ ]|MID(?:1014|0714)|PRO[VG]?(?:[0-9]{3,}[a-z]*|[0-9]{2}[a-z])'
  device: 'tablet'
  models:
    # explicit smartphone models
    - regex: 'PRO4611(?:PR201)?'
      model: 'Pro4611'
      device: 'smartphone'
    - regex: 'PROV400'
      model: 'Agate'
      device: 'smartphone'
    - regex: 'PROV350'
      model: 'ProV350'
      device: 'smartphone'

    - regex: 'PRO([VG]?(?:[0-9]{3,}[a-z]*|[0-9]{2}[a-z]))'
      model: 'Pro$1'
      device: 'smartphone'
    - regex: '(MID(?:1014|0714))'
      model: '$1'
    - regex: '((?:PMID|MIDC)[0-9a-z]+)[);/ ]'
      model: '$1'
    - regex: 'Polaroid'
      model: ''

# PolyPad
PolyPad:
  regex: 'POLY ?PAD'
  device: 'tablet'
  models:
    - regex: 'POLY ?PAD[_ \.]([a-z0-9]+)[);/ ]'
      model: '$1'
    - regex: 'POLY ?PAD[_\.]([a-z0-9]+)'
      model: '$1'

# Positivo
Positivo:
  regex: 'YPY_S450'
  device: 'smartphone'
  models:
    - regex: 'YPY_S450'
      model: 'YPY S450'

# Prestigio
Prestigio:
  regex: '(?:PMP|PAP)[0-9]+[a-z0-9_]+[);/ ]'
  device: 'tablet'
  models:
    - regex: '(PMP[0-9]+[a-z0-9_]+)[);/ ]'
      model: '$1'
    - regex: '(PAP[0-9]+[a-z0-9_]+(?: DUO)?)[);/ ]'
      model: '$1'
      device: 'smartphone'

# Sanyo
Sanyo:
  regex: 'Sanyo|MobilePhone[ ;]'
  device: 'feature phone'
  models:
    # explicit feature phone models
    - regex: 'SCP-?6750'
      model: 'Katana Eclipse X'
    - regex: 'SCP-?6760'
      model: 'Incognito'
    - regex: 'SCP-?6780'
      model: 'Innuendo'

    - regex: 'SANYO[ \-_]([a-z0-9\-]+)'
      model: '$1'
    - regex: 'MobilePhone ([a-z0-9\-]+)'
      model: '$1'

# Qilive
Qilive:
  regex: 'Qilive [0-9][^;/]*'
  device: 'smartphone'
  models:
    - regex: 'Qilive ([0-5][^;/]*) Build'
      model: '$1'
    - regex: 'Qilive ([0-5][^;/]*)/'
      model: '$1'
    - regex: 'Qilive ([6-9][^;/]*) Build'
      model: '$1'
      device: 'tablet'
    - regex: 'Qilive ([6-9][^;/]*)/'
      model: '$1'
      device: 'tablet'

# QMobile
QMobile:
  regex: 'QMobile|QTab|Q-Smart'
  device: 'smartphone'
  models:
    - regex: 'QTab[ _-]([^;/]+) Build'
      model: '$1 Tab'
      device: 'tablet'
    - regex: 'QTab[ _-]([^;/)]+)[;/)]'
      model: '$1 Tab'
      device: 'tablet'
    - regex: '(?:QMobile|Q-Smart)[ _-]([^;/]+) Build'
      model: '$1'
    - regex: '(?:QMobile|Q-Smart)[ _-]([^;/)]+)[;/)]'
      model: '$1'

# Quechua
Quechua:
  regex: 'Quechua Phone 5'
  device: 'smartphone'
  model: 'Quechua Phone 5'

# Ramos
Ramos:
  regex: 'Ramos ?([^/;]+) Build'
  device: 'tablet'
  model: '$1'

# Sendo
Sendo:
  regex: 'Sendo([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Turbo-X
Turbo-X:
  regex: 'Turbo-X'
  device: 'smartphone'
  models:
    - regex: 'Turbo-X Ice[);/ ]'
      device: 'tablet'
      model: 'Ice'
    - regex: 'Turbo-X Tablet([^;/]+) Build'
      device: 'tablet'
      model: 'Tablet$1'
    - regex: 'Turbo-X ([^;/]+) Build'
      model: '$1'

# Spice
Spice:
  regex: 'Spice'
  device: 'smartphone'
  models:
    - regex: 'Spice[ _\-]?([^/;]+)(?:[\)]| Build)'
      model: '$1'
    - regex: 'Spice[ _\-]?([^/;]+)(?:/|$)'
      model: '$1'

# Sharp
Sharp:
  regex: 'SHARP|SBM|SH-[0-9]+[a-z]?[);/ ]|AQUOS'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'SH-02E'
      model: 'Aquos Phone Zeta'
    - regex: 'SH06D'
      model: 'Aquos Phone SH-06D'

    # explicit tablet models
    - regex: 'SH-08E'
      device: 'tablet'
      model: 'Sharp Aquos Pad'

    - regex: '(LC-(?:[0-9]{2})[a-z0-9]+)(?:[);/ ]|$)'
      device: 'tv'
      model: '$1'
    - regex: 'SHARP-AQUOS|AQUOSBrowser'
      device: 'tv'
      model: 'Aquos Net Plus'
    - regex: 'SHARP[ \-]([a-z0-9\-]+)'
      model: '$1'
    - regex: '(?:SHARP|SBM)([a-z0-9]+)'
      model: '$1'
    - regex: '(SH-[0-9]+[a-z]?)[);/ ]'
      model: '$1'

# Softbank
Softbank:
  regex: 'Softbank|J-PHONE'
  device: 'smartphone'
  models:
    - regex: 'Softbank/[12]\.0/([a-z0-9]+)'
      model: '$1'
    - regex: '([a-z0-9]+);Softbank;'
      model: '$1'
    - regex: 'J-PHONE/[0-9]\.[0-9]/([a-z0-9\-]+)'
      model: '$1'

# Star
Star:
  regex: 'N(9[5678]00|8800|9000|9977)[);/ ]'
  device: 'smartphone'
  models:
    - regex: 'N9000'
      model: 'Note 3'

    - regex: 'N(9[5678]00|8800|9977)[);/ ]'
      model: 'N$1'

# Kindle
Amazon:
  regex: 'KF(?:OT|TT|JWI|JWA|SOWI|A[PRS]WI|THWI|SAW[IA])[);/ ]|Kindle|Silk/\d+\.\d+|Amazon (?:Tate|Jem)|AFT[BM]|SD4930UR'
  device: 'tablet'
  models:
    - regex: 'AFTB'
      model: 'Fire TV'
      device: 'tv'
    - regex: 'AFTM'
      model: 'Fire TV stick'
      device: 'tv'
    - regex: 'KFTT[);/ ]'
      model: 'Kindle Fire HD'
    - regex: 'KFJWI[);/ ]|Amazon Jem'
      model: 'Kindle Fire HD 8.9" WiFi'
    - regex: 'KFJWA[);/ ]'
      model: 'Kindle Fire HD 8.9" 4G'
    - regex: 'KFSOWI[);/ ]|Amazon Tate'
      model: 'Kindle Fire HD 7" WiFi'
    - regex: 'KFTHWI[);/ ]'
      model: 'Kindle Fire HDX 7" WiFi'
    - regex: 'KFTHWA[);/ ]'
      model: 'Kindle Fire HDX 7" 4G'
    - regex: 'KFAPWI[);/ ]'
      model: 'Kindle Fire HDX 8.9" WiFi'
    - regex: 'KFAPWA[);/ ]'
      model: 'Kindle Fire HDX 8.9" 4G'
    - regex: 'KFARWI[);/ ]'
      model: 'Fire HD 6'
    - regex: 'KFASWI[);/ ]'
      model: 'Fire HD 7'
    - regex: 'KFSAWI[);/ ]'
      model: 'Fire HDX 8.9'
    - regex: 'KFSAWA[);/ ]'
      model: 'Fire HDX 8.9 4G'
    - regex: 'SD4930UR'
      model: 'Fire Phone'
      device: 'smartphone'


    - regex: 'KFOT|Kindle Fire|Silk/\d+\.\d+'
      model: 'Kindle Fire'
    - regex: 'Kindle'
      model: 'Kindle'

# Symphony
Symphony:
  regex: 'SYMPHONY[ \_]([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# Qtek
Qtek:
  regex: 'Qtek[ _]?([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# T-Mobile
T-Mobile:
  regex: 'T-Mobile[ _][a-z0-9 ]+'
  device: 'smartphone'
  models:
    - regex: 'T-Mobile[ _]([a-z0-9_ ]+) Build'
      model: '$1'
    - regex: 'T-Mobile[ _]([a-z0-9_ ]+)'
      model: '$1'

# Tcl
TCL:
  regex: 'TCL[ -][a-z0-9]+|TCL[_ -][^;/]+ Build'
  device: 'smartphone'
  models:
    - regex: 'TCL[_ -]([^;/]+) Build'
      model: '$1'
    - regex: 'TCL[ -]([a-z0-9]+)'
      model: '$1'

# Tecno Mobile
Tecno Mobile:
  regex: 'Tecno'
  device: 'smartphone'
  models:
    - regex: 'Tecno ([^;/]+) Build'
      model: '$1'
    - regex: 'Tecno_?([a-z0-9_\-]+)'
      model: '$1'

# Tesco
Tesco:
  regex: 'Hudl ([^/;]+) Build'
  device: 'tablet'
  model: 'Hudl $1'

# teXet
teXet:
  regex: '(NaviPad [^/;]*) Build'
  device: 'tablet'
  model: '$1'

# Telenor
Telenor:
  regex: 'Telenor'
  device: 'smartphone'
  models:
    - regex: 'Telenor[ _]([^;/]+) Build'
      model: '$1'
    - regex: 'Telenor[ _]([^a-z0-9_]+)\)'
      model: '$1'

# Telit
Telit:
  regex: 'Telit'
  device: 'feature phone'
  models:
    - regex: 'Telit_Mobile_Terminals-([a-z0-9]+)'
      model: '$1'
    - regex: 'Telit[\-_]?([a-z0-9]+)'
      model: '$1'

# ThL
ThL:
  regex: 'ThL[ _-]'
  device: 'smartphone'
  models:
    - regex: 'ThL[ _-]*([^;/]+) Build'
      model: '$1'
    - regex: 'ThL[ _-]*([^ ;/)]+)[ ;/)]'
      model: '$1'

# Tianyu
TIANYU:
  regex: 'TIANYU'
  device: 'feature phone'
  models:
    - regex: 'TIANYU ([a-z0-9]+)'
      model: '$1'
    - regex: 'TIANYU-KTOUCH/([a-z0-9]+)'
      model: '$1'

# Tolino
Tolino:
  regex: 'Tolino Tab ([^/;]+) Build'
  device: 'tablet'
  model: 'Tolino Tab $1'

# Toplux
Toplux:
  regex: 'Toplux ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Trevi
Trevi:
  regex: 'Trevi[ _]|TAB[ _]10[ _]3G[ _]V16|TAB[ _](7|8)[ _]3G[ _]V8|TAB9 3G|MINITAB 3GV|Phablet[ _](?:4|4\.5|5|5\,3|6)[ _]?[C|S|Q]|REVERSE[ _]5\.5[ _]?Q'
  device: 'tablet'
  models:
    - regex: 'TAB[ _]?(7|8)[ _]3G[ _]V8'
      model: 'TAB $1 3G V8'
    - regex: 'TAB[ _]?9[ _]3G[ _]V8'
      model: 'TAB 9 3G V8'
    - regex: 'TAB[ _]?9[ _]3G'
      model: 'TAB 9 3G'
    - regex: 'TAB[ _]10[ _]3G[ _]V16'
      model: 'TAB 10 3G V16'
    - regex: 'MINITAB 3GV'
      model: 'MINITAB 3G V'
    - regex: '(?:Trevi_)?Phablet[ _]4[ _]?C'
      model: 'Phablet 4 C'
      device: 'smartphone'
    - regex: '(?:Trevi_)?Phablet[ _]4[ _]?S'
      model: 'Phablet 4 S'
      device: 'smartphone'
    - regex: '(?:Trevi_)?Phablet[ _]4.5[ _]?Q'
      model: 'Phablet 4.5Q'
      device: 'smartphone'
    - regex: '(?:Trevi_)?PHABLET[ _]5[ _]?S'
      model: 'Phablet 5 S'
      device: 'smartphone'
    - regex: '(?:Trevi_)?PHABLET[ _]5,3[ _]?Q'
      model: 'Phablet 5.3 Q'
      device: 'phablet'
    - regex: '(?:Trevi_)?REVERSE[ _]5.5[ _]?Q'
      model: 'Phablet 5.5 Q REVERSE'
      device: 'phablet'
    - regex: '(?:Trevi_)?PHABLET[ _]6[ _]?S'
      model: 'Phablet 6 S'
      device: 'phablet'

    - regex: 'Trevi[_]([^;/]+) Build'
      model: '$1'

#TVC
TVC:
  regex: '(NuclearSX-SP5)'
  device: 'smartphone'
  model: 'Nuclear SX-SP5'

# Unowhy
Unowhy:
  regex: 'QOOQ '
  device: 'tablet'
  model: 'QOOQ'


# UTStarcom
UTStarcom:
  regex: 'utstar[ _-]?([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Uniscope
Uniscope:
  regex: 'Uniscope'
  device: 'smartphone'
  models:
    - regex: 'Uniscope[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'Uniscope[ _\-]?([^);/ ]+)'
      model: '$1'

# Vastking
Vastking:
  regex: 'M910A[);/ ]'
  device: 'tablet'
  models:
    - regex: 'M910A[);/ ]'
      model: 'M910A'

# ViewSonic
ViewSonic:
  regex: 'ViewSonic|VSD[0-9]+[);/ ]|ViewPad|ViewPhone'
  device: 'smart display'
  models:
    - regex: '(?:ViewSonic-)?ViewPhone ?([^;/]+) Build'
      model: 'ViewPhone $1'
      device: 'smartphone'
    - regex: '(?:ViewSonic-)?ViewPad ?([^;/]+) Build'
      model: 'ViewPad $1'
      device: 'tablet'
    - regex: '(VSD[0-9]+)[);/ ]'
      model: '$1'

# Vitelcom
Vitelcom:
  regex: 'Vitelcom|portalmmm/[12].0 TSM'
  device: 'feature phone'
  models:
    - regex: 'TSM-([a-z0-9]+)'
      model: '$1'
    - regex: 'TSM([a-z0-9\-]+)'
      model: '$1'
    - regex: 'portalmmm/[12].0 (TSM[a-z0-9 ]+)'
      model: '$1'

# VK Mobile
VK Mobile:
  regex: 'VK[\-]?([a-z0-9 ]+)[ ;\)/]'
  device: 'feature phone'
  model: '$1'

# Vertu
Vertu:
  regex: 'Vertu[ ]?([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Videocon
Videocon:
  regex: 'Videocon[_ \-]|VT75C'
  device: 'smartphone'
  models:
    - regex: 'Videocon[_ \-]([a-z0-9]+)'
      model: '$1'
    - regex: 'VT75C[/;) ]'
      model: 'VT75C'

# Vodafone
Vodafone:
  regex: 'Vodafone[ _-]|Smart ?Tab ?(?:III? ?)?(?:|4G|7|10)[);/ -]|VodafoneSmartChat'
  device: 'smartphone'
  models:
    - regex: 'Vodafone[ _]875[);/ ]'
      model: 'Smart Mini' # Alcatel
    - regex: 'Vodafone[ _]975N?[);/ ]'
      model: 'Smart 3' # Alcatel
    - regex: 'Vodafone[ _]785[);/ ]'
      model: 'Smart 4 Mini'
    - regex: 'Vodafone[ _]890N[);/ ]'
      model: 'Smart 4 Turbo' # Coolpad 3601U
    - regex: 'Vodafone[ _]985N[);/ ]'
      model: 'Smart 4 Power'
    - regex: 'VodafoneSmartChat'
      model: 'Smart Chat'

    # explicit table models
    - regex: 'Smart ?Tab ?3G'
      device: 'tablet'
      model: 'Smart Tab 3G'
    - regex: 'Smart ?Tab ?4G'
      device: 'tablet'
      model: 'Smart Tab 4G'  # Alcatel
    - regex: 'SmartTab7[);/ -]'
      model: 'Smart Tab 7' # ZTE
      device: 'tablet'
    - regex: 'SmartTab10[);/ -]'
      model: 'Smart Tab 10' # ZTE
      device: 'tablet'
    - regex: 'Smart ?Tab ?II ?7'
      model: 'Smart Tab II 7' # Lenovo
      device: 'tablet'
    - regex: 'Smart ?Tab ?II ?10'
      model: 'Smart Tab II 10' # Lenovo
      device: 'tablet'
    - regex: 'Smart ?Tab ?III ?7'
      model: 'Smart Tab III 7' # Lenovo
      device: 'tablet'
    - regex: 'Smart ?Tab ?III ?10'
      model: 'Smart Tab III 10' # Lenovo
      device: 'tablet'

    - regex: 'Vodafone[ _-]([^;/]+) Build'
      model: '$1'
    - regex: 'Vodafone[ _-]([a-z0-9_-]+)'
      model: '$1'

# Voto
Voto:
  regex: 'VOTO[ _\-]|VT8[89]8[;/) ]'
  device: 'smartphone'
  models:
    - regex: 'VOTO[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'VOTO[ _\-]?([^);/ ]+)'
      model: '$1'
    - regex: '(VT8[89]8)[;/) ]'
      model: '$1'

# Voxtel
Voxtel:
  regex: 'Voxtel_([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Walton
Walton:
  regex: 'Walton|Walpad|Primo[ _](C[1234]?|D[12345]|E[12345]|EF[23]?|EM|F[123456]i?|G[12345]|GF[234]?|GH[23]?|GM|H[23]|HM|N|N1|NF|NX2?|R[123]|RH2?|RM2?|RX[23]?|S[1234]|V1|X[123]|Z|ZX)'
  device: 'smartphone'
  models:
    - regex: 'Walpad ([^;/]+) Build'
      device: 'tablet'
      model: 'Primo Walpad $1'
    - regex: 'Walton[ _]([^;/]+) Build'
      model: '$1'
    - regex: 'Walton[ _]([^;/]+)\)'
      model: '$1'
    - regex: 'Primo[ _]([^;/]+) Build'
      model: 'Primo $1'
    - regex: 'Primo[ _]([0-9a-z]+)'
      model: 'Primo $1'

# Wellcom
WellcoM:
  regex: 'WELLCOM[ _\-/]([a-z0-9]+)'
  device: 'smartphone'
  model: '$1'

# Wexler
Wexler:
  regex: 'Wexler|TAB[ _]10Q[);/ ]|ZEN[ _](?:4\.5|4\.7|5)'
  device: 'tablet'
  models:
    - regex: '(?:Wexler[ _\-\.])?ZEN[ _]4\.5[);/ ]'
      model: 'ZEN 4.5'
      device: 'smartphone'
    - regex: '(?:Wexler[ _\-\.])?ZEN[ _]4\.7[);/ ]'
      model: 'ZEN 4.7'
      device: 'smartphone'
    - regex: '(?:Wexler[ _\-\.])?ZEN[ _]5[);/ ]'
      model: 'ZEN 5'
      device: 'smartphone'
    - regex: '(?:Wexler[ _\-\.])?TAB[ _]10Q[);/ ]'
      model: 'TAB 10Q'
    - regex: 'Wexler[ _\-\.]([^;/]+) Build'
      model: '$1'
    - regex: 'Wexler[ _\-\.]([^);/]+)[);/]'
      model: '$1'

# Wiko
Wiko:
  regex: '(?:WIKO-)?CINK_[a-z0-9_]+|(?:WIKO-)?HIGHWAY_[a-z0-9_]+|(?:WIKO-)?(?:Cink.*|Highway.*|Iggy|Stairway|Rainbow|Darkside|Darkmoon|Darkfull|Darknight|Sublim|Ozzy|JIMMY|Barry|Birdy|Bloom|Getaway|Goa|Kite|Lenny|Slide|Sunset|Wax|Ridge(?: Fab)?)(?: 4G)? Build'
  device: 'smartphone'
  models:
    - regex: '(?:WIKO-)?CINK_([a-z0-9_]+)'
      model: 'Cink $1'
    - regex: '(?:Wiko-)?Cink(.*) Build'
      model: 'Cink$1'
    - regex: '(?:WIKO-)?HIGHWAY_([a-z0-9_]+)'
      model: 'Highway $1'
    - regex: '(?:Wiko-)?Highway(.*) Build'
      model: 'Highway$1'
    - regex: '(?:WIKO-)?Iggy Build'
      model: 'Iggy'
    - regex: '(?:WIKO-)?Stairway Build'
      model: 'Stairway'
    - regex: '(?:WIKO-)?Ridge Build'
      model: 'Ridge'
    - regex: '(?:WIKO-)?Ridge Fab 4G Build'
      model: 'Ridge Fab 4G'
    - regex: '(?:WIKO-)?Ridge 4G Build'
      model: 'Ridge 4G'
    - regex: '(?:WIKO-)?Rainbow Build'
      model: 'Rainbow'
    - regex: '(?:WIKO-)?Rainbow 4G Build'
      model: 'Rainbow 4G'
    - regex: '(?:WIKO-)?Darkside Build'
      model: 'Darkside'
    - regex: '(?:WIKO-)?Darkmoon Build'
      model: 'Darkmoon'
    - regex: '(?:WIKO-)?Darkfull Build'
      model: 'Darkfull'
    - regex: '(?:WIKO-)?Darknight Build'
      model: 'Darknight'
    - regex: '(?:WIKO-)?Sublim Build'
      model: 'Sublim'
    - regex: '(?:WIKO-)?Ozzy Build'
      model: 'Ozzy'
    - regex: '(?:WIKO-)?Barry Build'
      model: 'Barry'
    - regex: '(?:WIKO-)?Birdy Build'
      model: 'Birdy'
    - regex: '(?:WIKO-)?Bloom Build'
      model: 'Bloom'
    - regex: '(?:WIKO-)?JIMMY Build'
      model: 'Jimmy'
    - regex: '(?:WIKO-)?Getaway Build'
      model: 'Getaway'
    - regex: '(?:WIKO-)?Goa Build'
      model: 'Goa'
    - regex: '(?:WIKO-)?Kite Build'
      model: 'Kite'
    - regex: '(?:WIKO-)?Lenny Build'
      model: 'Lenny'
    - regex: '(?:WIKO-)?Slide Build'
      model: 'Slide'
    - regex: '(?:WIKO-)?Sunset Build'
      model: 'Sunset'
    - regex: '(?:WIKO-)?Wax Build'
      model: 'Wax'

# Wolder
Wolder:
  regex: 'miSmart|miTab'
  device: 'smartphone'
  models:
    - regex: 'miSmart[ \-_]?([^/]+) Build'
      model: 'miSmart $1'
    - regex: 'miTab[ \-_]?([^/]+) Build'
      device: 'tablet'
      model: 'miTab $1'

# Wonu
Wonu:
  regex: 'Wonu ([a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Woxter
Woxter:
  regex: 'Woxter ([^/;]+) Build'
  device: 'tablet'
  model: '$1'

#Xiaomi
Xiaomi:
  regex: 'Xiaomi|(MI [a-z0-9]+|MI-One[ _]?[a-z0-9]+)[);/ ]|HM ([^/;]+) Build|(2014501|2014011|201481[13]|201302[23]|2013061) Build|Redmi'
  device: 'smartphone'
  models:
    # specific smartphone models
    - regex: 'Xiaomi_2014501|2014501 Build'
      model: 'Hongmi 4G'
    - regex: 'Xiaomi_2014011|2014011 Build'
      model: 'Hongmi 1S'
    - regex: 'Xiaomi_201481[13]|201481[13] Build'
      model: 'Hongmi 2 4G'
    - regex: 'Xiaomi_201302[23]|201302[23] Build'
      model: 'Hongmi'
    - regex: 'Xiaomi_2013061|2013061 Build'
      model: 'MI 3'

    - regex: 'Redmi Note ([^;/]+)? Build'
      model: 'Redmi Note $1'
      device: 'phablet'
    - regex: 'Redmi ([^;/]+)? Build'
      model: 'Redmi $1'
    - regex: 'MI Note ([^;/]+)? Build'
      model: 'MI Note $1'
      device: 'phablet'
    - regex: '(MI(?:-One)?[ _](?:[^;/]*))Build'
      model: '$1'
    - regex: '(MI [a-z0-9]+|MI-One[ _]?[a-z0-9]+)[);/ ]'
      model: '$1'
    - regex: 'HM Note ([^/;]+) Build'
      device: 'phablet'
      model: 'HM Note $1'
    - regex: 'HM ([^/;]+) Build'
      model: 'HM $1'

# Xolo
Xolo:
  regex: 'Xolo|(?:Q600|Q700s?|Q800|Q1000s|Q1000[ _]Opus|Q1010i|Q2000|Omega[ _]5.[05])[);/ ]'
  device: 'smartphone'
  models:
    - regex: '(Q600|Q700s?|Q800|Q1000s|Q1000[ _]Opus|Q1010i|Q2000|Omega[ _]5.[05])[);/ ]'
      model: '$1'
    - regex: 'Xolo[ _]?([^;/]+) Build'
      model: '$1'
    - regex: 'Xolo[ _]?([a-z0-9_-]+)'
      model: '$1'

# Yarvik
Yarvik:
  regex: 'Xenta[ \-]Tab|Luna TAB|TAB09-410|TAB10-410|TAB07-485|TAB0[78]-200|TAB08-201-3G|TAB9-200|TAB09-211|TAB10-2[01]1|TAB13-201'
  device: 'tablet'
  models:
    # explicit tablet models
    - regex: 'Luna TAB07-920N'
      model: 'Luna 7'
    - regex: 'Luna TAB07-10[01]'
      model: 'Luna 7c'
    - regex: 'Luna TAB274'
      model: 'Luna 7c'
    - regex: 'Luna TAB474'
      model: 'Luna 10'
    - regex: 'Luna TAB10-150'
      model: 'Luna 10c'
    - regex: 'TAB09-410'
      model: 'Noble 9.7'
    - regex: 'TAB10-410'
      model: 'Noble 10.1'
    - regex: 'TAB07-485'
      model: 'Noble Mini'
    - regex: 'Xenta-TAB07-21[01]'
      model: 'Xenta 7c'
    - regex: 'TAB07-200'
      model: 'Xenta 7ic'
    - regex: 'TAB08-200'
      model: 'Xenta 8ic'
    - regex: 'TAB08-201-3G'
      model: 'Xenta 8c'
    - regex: 'TAB9-200'
      model: 'Xenta 9.7ic'
    - regex: 'TAB09-211'
      model: 'Xenta 9.7ic+'
    - regex: 'TAB10-2[01]1'
      model: 'Xenta 10ic'
    - regex: 'TAB13-201'
      model: 'Xenta 13c'

# Yuandao
Yuandao:
  regex: 'N101[ _]DUAL(?:[ _]CORE)?(?:[ _]?2|\|\|)?(?:[ _]V11)?[);/ ]'
  device: 'tablet'
  model: 'N101'

# Yusun
Yusun:
  regex: 'Yusun|LA2-T'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'LA2-T'
      model: 'LA2-T'

    - regex: 'Yusun ([^;/]+) Build'
      model: '$1'
    - regex: 'Yusun ([a-z0-9_\-\+]+)'
      model: '$1'

# Ytone
Ytone:
  regex: 'YTONE[ _\-]'
  device: 'smartphone'
  models:
    - regex: 'YTONE[ _\-]?([^/;]+) Build'
      model: '$1'
    - regex: 'YTONE[ _\-]?([^);/ ]+)'
      model: '$1'

# Zonda
Zonda:
  regex: '(ZM(?:CK|EM|TFTV|TN)[a-z0-9]+)'
  device: 'feature phone'
  model: '$1'

# Toshiba
Toshiba:
  regex: 'Toshiba|TSBNetTV/|portalmmm/[12].0 TS|T-01C|T-0[12]D|IS04|IS11T|AT1S0|AT300SE|AT(100|200|270|300|330|374|400|470|500|503|570|703|830)'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'T-01C'
      model: 'Regza T-01C'
    - regex: 'T-01D'
      model: 'Regza T-01D'
    - regex: 'T-02D'
      model: 'Regza T-02D'
    - regex: 'IS04'
      model: 'Regza IS04'
    - regex: 'IS11T'
      model: 'Regza IS11T'

    # explicit tablet models
    - regex: 'AT1S0'
      model: 'Regza AT1S0'
      device: 'tablet'
    - regex: 'AT300SE'
      model: 'Regza AT300SE'
      device: 'tablet'
    - regex: 'AT500a'
      model: 'Regza AT500a'
      device: 'tablet'
    - regex: 'AT(100|200|270|300|330|374|400|470|500|503|570|703|830)'
      model: 'Regza AT$1'
      device: 'tablet'

    - regex: 'TSBNetTV/'
      device: 'tv'
      model: ''
    - regex: 'Toshiba[ /_\-]?([a-z0-9_ \-]+) Build'
      model: '$1'
    - regex: 'Toshiba[ /_\-]?([a-z0-9_\-]+)'
      model: '$1'
    - regex: 'portalmmm/[12].0 (TS[a-z0-9 ]+)'
      model: '$1'

# Fly
Fly:
  regex: 'Fly(?!Flow|touch)|MERIDIAN-'
  device: 'smartphone'
  models:
    - regex: 'Fly[ _\-]?([a-z0-9_]+)/'
      model: '$1'
      device: 'feature phone'
    - regex: 'Flylife[ _\-]?([^/;]+) Build'
      model: 'Flylife $1'
      device: 'tablet'
    - regex: 'Fly[ _\-]?([a-z0-9]+)'
      model: '$1'
    - regex: 'MERIDIAN-([a-z0-9]+)'
      model: '$1'

# Web TV
Web TV:
  regex: 'WebTV/(\d+\.\d+)'
  device: 'tv'
  model: ''

# Zeemi
Zeemi:
  regex: 'ZEEMI[ _-]'
  device: 'smartphone'
  models:
    - regex: 'ZEEMI[ _-]([^/;]+) Build'
      model: '$1'
    - regex: 'ZEEMI[ _-]([^/;)]+)[/;)]'
      model: '$1'

# Zopo
Zopo:
  regex: '(?:ZOPO[_ ])?(ZP[0-9]{2,}[^/;]+) Build'
  device: 'smartphone'
  model: '$1'

# ZTE
ZTE:
  regex: 'ZTE|AxonPhone|([a-z0-9]+)_USA_Cricket|(?:Blade S6|N9[15]8St|NX(?:403A|40[X2]|507J|503A|505J|506J|508J|510J|511J|513J|601J)|Z331|N9510|N9180|N9101|N9515|N952[01]|N9810|N799D|[UV]9180)[);/ ]'
  device: 'smartphone'
  models:
    # explicit smartphone models
    - regex: 'N799D[);/ ]'
      model: 'MTS Blaze 4'
    - regex: 'N918St[);/ ]'
      model: 'V5S'
    - regex: 'N958St[);/ ]'
      model: 'V5 Max'
    - regex: 'N9101[);/ ]'
      model: 'Imperial'
    - regex: 'N9180[);/ ]'
      model: 'V5'
    - regex: 'N9510[);/ ]'
      model: 'Wrap 4G'
    - regex: 'N9515[);/ ]'
      model: 'Wrap Sync'
    - regex: 'N9520[);/ ]'
      model: 'Boost Max'
    - regex: 'N9521[);/ ]'
      model: 'Boost Max+'
    - regex: 'N9810[);/ ]'
      model: 'Vital'
    - regex: 'NX40[X2][);/ ]'
      model: 'Nubia Z5 mini'
    - regex: 'NX403A[);/ ]'
      model: 'Nubia Z5S mini'
    - regex: 'NX503A[);/ ]'
      model: 'Nubia Z5S'
    - regex: 'NX506J[);/ ]'
      model: 'Nubia Z7'
    - regex: 'NX507J[);/ ]'
      model: 'Nubia Z7 mini'
    - regex: 'NX505J[);/ ]'
      model: 'Nubia Z7 max'
    - regex: 'NX508J[);/ ]'
      model: 'Nubia Z9'
    - regex: 'NX511J[);/ ]'
      model: 'Nubia Z9 mini'
    - regex: 'NX510J[);/ ]'
      model: 'Nubia Z9 max'
    - regex: 'NX513J[);/ ]'
      model: 'Nubia My Prague'
    - regex: 'NX601J[);/ ]'
      model: 'Nubia X6'
    - regex: '[UV]9180[);/ ]'
      model: 'V5 Red Bull'
    - regex: 'Z331[);/ ]'
      model: 'Z331'
    - regex: 'Blade S6[);/ ]'
      model: 'Blade S6'

    - regex: 'AxonPhone ([^;/]+) Build'
      model: 'AxonPhone $1'
    - regex: '([a-z0-9]+)_USA_Cricket'
      model: '$1'
    - regex: 'ZTE[\- ](V98|V96A|V81|V70)[);/ ]'
      model: '$1'
      device: 'tablet'
    - regex: 'ZTE[\- ]([a-z0-9\-_ ]+) Build'
      model: '$1'
    - regex: 'ZTE-(?:G |G-)?([a-z0-9 _]+)'
      model: '$1'
    - regex: 'ZTE[ _]([a-z0-9]+)'
      model: '$1'

# Symbian to Nokia ??
# Change name from Nokia to other to not change above Nokia element
#Nokia:
#  regex: 'Symbian'
#  device: 'feature phone'

# OnePlus
OnePlus:
  regex: 'A0001 Build'
  device: 'smartphone'
  models:
    - regex: 'A0001'
      model: 'One'
