OUI                                                         Organization                                 
OUI-28/MA-M Range                                           Organization                                 
                                                            Address                                      

74-1A-E0   (hex)		Private
900000-9FFFFF     (base 16)		Private

20-85-93   (hex)		IOG Products LLC
B00000-BFFFFF     (base 16)		IOG Products LLC
				9737 LURLINE AVENUE
				CHATSWORTH  CA  91311
				US

B0-C5-CA   (hex)		Private
F00000-FFFFFF     (base 16)		Private

B0-1F-81   (hex)		Private
F00000-FFFFFF     (base 16)		Private

20-85-93   (hex)		Shanghai Kenmyond Industrial Network Equipment Co.,Ltd
D00000-DFFFFF     (base 16)		Shanghai Kenmyond Industrial Network Equipment Co.,Ltd
				15/F,NO3003,Baoyang Road,Baoshan District
				Shanghai  Shanghai  201201
				CN

20-85-93   (hex)		H3 Industries, Inc.
A00000-AFFFFF     (base 16)		H3 Industries, Inc.
				12758 W Deep Canyon Dr.
				Star  ID  83669
				US

24-15-10   (hex)		Teknic, Inc.
B00000-BFFFFF     (base 16)		Teknic, Inc.
				115 Victor Heights Pkwy
				14564,Victor  NY  14564
				US

98-06-37   (hex)		GS GLOBAL SECURITY INC
500000-5FFFFF     (base 16)		GS GLOBAL SECURITY INC
				30 Pennsylvania Ave, Unit 16,
				CONCORD  ONTARIO  L4K 4A5
				CA

B4-A2-EB   (hex)		Shanghai Shenou Communication Equipment Co., Ltd.
C00000-CFFFFF     (base 16)		Shanghai Shenou Communication Equipment Co., Ltd.
				No. 1188, Kungang Road, Songjiang District
				Shanghai  Shanghai  200000
				CN

24-15-10   (hex)		GANZHOU DEHUIDA TECHNOLOGY CO., LTD
500000-5FFFFF     (base 16)		GANZHOU DEHUIDA TECHNOLOGY CO., LTD
				Dehuida Science and Technology Park, Huoyanshan Road, Anyuan District
				Ganzhou  Jiangxi  342100
				CN

24-15-10   (hex)		Nile Global Inc
200000-2FFFFF     (base 16)		Nile Global Inc
				10915 Miramonte Rd
				Cupertino  CA  95014
				US

24-15-10   (hex)		Helen of Troy
D00000-DFFFFF     (base 16)		Helen of Troy
				1 Helen of Troy Plaza
				El Paso  TX  79912
				US

98-06-37   (hex)		Zoleo Inc.
000000-0FFFFF     (base 16)		Zoleo Inc.
				7a Taymall Avenue
				Toronto  ON  M8Z 3Y8
				CA

98-06-37   (hex)		E. P. Schlumberger
100000-1FFFFF     (base 16)		E. P. Schlumberger
				1 rue Henri Becquerel
				Clamart    92140
				FR

B4-37-D1   (hex)		Private
F00000-FFFFFF     (base 16)		Private

44-D5-F2   (hex)		SYS TEC electronic GmbH
A00000-AFFFFF     (base 16)		SYS TEC electronic GmbH
				Am Windrad 2
				Heinsdorfergrund   Sachsen  D-08468
				DE

44-D5-F2   (hex)		Shenzhen Nation RFID Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Shenzhen Nation RFID Technology Co.,Ltd.
				Room 816, Building A, Yuanzheng Venture Building, No. 19 Langshan Road, Xili Street, Nanshan District
				ShenZhen  Guangdong  518000
				CN

D0-5F-64   (hex)		TytoCare LTD.
800000-8FFFFF     (base 16)		TytoCare LTD.
				12 Haomanut st., 2nd floor
				Netanya  Merkaz  4250445
				IL

D0-5F-64   (hex)		Cyrus Technology GmbH
600000-6FFFFF     (base 16)		Cyrus Technology GmbH
				Hergelsbendenstraße 49
				Aachen    52080
				DE

D0-5F-64   (hex)		Montblanc-Simplo GmbH
E00000-EFFFFF     (base 16)		Montblanc-Simplo GmbH
				Hellgrundweg 100
				Hamburg  Hamburg  22525
				DE

44-D5-F2   (hex)		Beam Communications Pty Ltd
600000-6FFFFF     (base 16)		Beam Communications Pty Ltd
				U5/8 Anzed Court
				Mulgrave  Victoria  3170
				AU

FC-A4-7A   (hex)		Innovative Advantage
700000-7FFFFF     (base 16)		Innovative Advantage
				15353 NE 90th Street
				Redmond   WA  98052
				US

FC-A4-7A   (hex)		 Shenzhen Elebao Technology Co., Ltd
A00000-AFFFFF     (base 16)		 Shenzhen Elebao Technology Co., Ltd
				F/6, Tower A, Zhihuichuangxin Center Bldg,Qianjin Road, XixiangTown, Bao’an District
				shenzhen  GUANGDONG  518126
				CN

FC-A4-7A   (hex)		Shenzhen ALFEYE Technology CO.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen ALFEYE Technology CO.,Ltd
				Dingye Business Center321, Building A, Jingbei Industrial Park, No. 82, Intersection of Baoan Avenue and Xin'an 6th Road, Haiyu Community, Xin'an Street, Bao'an District
				Shenzhen  Guangdong  518000
				CN

2C-16-BD   (hex)		LINGDONG TECHNOLOGY (BEIJING) CO. LTD
B00000-BFFFFF     (base 16)		LINGDONG TECHNOLOGY (BEIJING) CO. LTD
				2603-01, Floor 22, building 2, No.66 Zhongguancun East Road, Haidian District, Beijing
				Beijing    100080
				CN

2C-16-BD   (hex)		Beijing CHJ Automotive Co., Ltd.
C00000-CFFFFF     (base 16)		Beijing CHJ Automotive Co., Ltd.
				Room 101, Building 1, No. 4 Hengxing Road, Gaoliying, Shunyi District
				Beijing  Beijing  101303
				CN

B4-A2-EB   (hex)		Quantitec GmbH
B00000-BFFFFF     (base 16)		Quantitec GmbH
				Elisabethenstr. 3a
				Hofheim am Taunus  Hessen  65719
				DE

B4-A2-EB   (hex)		CURRENT WAYS, INC.
900000-9FFFFF     (base 16)		CURRENT WAYS, INC.
				10221 BUENA VISTA AVE
				SANTEE  CA  92071
				US

B4-A2-EB   (hex)		Annapurna labs
500000-5FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

B4-A2-EB   (hex)		Hengkang（Hangzhou）Co.,Ltd
A00000-AFFFFF     (base 16)		Hengkang（Hangzhou）Co.,Ltd
				Industrial Area,Huanghu Town,Yuhang District
				Hangzhou  Zhejiang  311118
				CN

8C-59-3C   (hex)		Guralp Systems Limited
400000-4FFFFF     (base 16)		Guralp Systems Limited
				3 Midas House
				Reading  Berkshire  RG7 8EA
				GB

8C-59-3C   (hex)		Beida Jade Bird Universal Fire Alarm Device CO.,LTD.
200000-2FFFFF     (base 16)		Beida Jade Bird Universal Fire Alarm Device CO.,LTD.
				Jade Bird Building C, 207 Chengfu RD, Haidian District
				Beijing  Beijing  100871
				CN

8C-59-3C   (hex)		OBO Pro.2 Inc.
700000-7FFFFF     (base 16)		OBO Pro.2 Inc.
				2148 Bering Dr.
				San Jose  CA  95131
				US

8C-59-3C   (hex)		GENIS
900000-9FFFFF     (base 16)		GENIS
				1111, 11F RACREUM, 26 Wiryeseoil-ro
				Seongnam-si  Gyeonggi-do  13647
				KR

D0-C8-57   (hex)		Beijing Inspiry Technology Co., Ltd. 
500000-5FFFFF     (base 16)		Beijing Inspiry Technology Co., Ltd. 
				Building No. 5, East Zone, No. 10, Xibeiwang East Road, Haidian District
				Beijing   Beijing   100092
				CN

BC-97-40   (hex)		Shanghai Laisi Information Technology Co.,Ltd
500000-5FFFFF     (base 16)		Shanghai Laisi Information Technology Co.,Ltd
				1001,21#,No.1158 Zhongxin RD,Songjiang district Shanghai
				shanghai    201614
				CN

F4-0E-11   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D0-C8-57   (hex)		E-T-A Elektrotechnische Apparate GmbH
E00000-EFFFFF     (base 16)		E-T-A Elektrotechnische Apparate GmbH
				Industriestr. 2-8
				Altdorf    90518
				DE

BC-97-40   (hex)		Airfi Oy AB
700000-7FFFFF     (base 16)		Airfi Oy AB
				Piilipuunkatu 11
				RAISIO    21200
				FI

BC-97-40   (hex)		comtac AG
100000-1FFFFF     (base 16)		comtac AG
				Allenwindenstrasse 1
				Flurlingen    8247
				CH

BC-97-40   (hex)		Precision Galaxy Pvt. Ltd
300000-3FFFFF     (base 16)		Precision Galaxy Pvt. Ltd
				3rd Floor, No.22 Habibullah Road, T Nagar
				CHENNAI,Tamil Nadu  Tamilnadu  600017
				IN

60-95-CE   (hex)		Xiamen Sigmastar Technology Ltd.
600000-6FFFFF     (base 16)		Xiamen Sigmastar Technology Ltd.
				15th Floor ,Unit A,Chuangxin Building, Software Park, Xiamen Torch Hi-Tech Industrial Development Zone, Xiamen,China
				Xiamen  Fujian  361005
				CN

1C-82-59   (hex)		KeyWest Networks, Inc
B00000-BFFFFF     (base 16)		KeyWest Networks, Inc
				2200 N Glassell St
				Orange  CA  92865
				US

88-5D-90   (hex)		Private
F00000-FFFFFF     (base 16)		Private

60-95-CE   (hex)		Beijing Sinomedisite Bio-tech Co.,Ltd
B00000-BFFFFF     (base 16)		Beijing Sinomedisite Bio-tech Co.,Ltd
				No.9 Kangding Street,Economic-Technological Development Area
				Beijing  Beijing  100176
				CN

60-95-CE   (hex)		Siema Applications
000000-0FFFFF     (base 16)		Siema Applications
				35 rue Alfred Brinon
				Villeurbanne    69100
				FR

60-95-CE   (hex)		Trophy SAS
800000-8FFFFF     (base 16)		Trophy SAS
				4 rue F. Pelloutier
				Croissy-Beaubourg    77435
				FR

60-95-CE   (hex)		VNS Inc.
E00000-EFFFFF     (base 16)		VNS Inc.
				3F, No. 27, Lane 66, Ruiguang Rd.
				Taipei  Taiwan  11466
				TW

84-8B-CD   (hex)		exodraft a/s
500000-5FFFFF     (base 16)		exodraft a/s
				C. F. Teiegens Boulevard 41
				Odense SØ    5220
				DK

1C-82-59   (hex)		3xLOGIC Inc.
100000-1FFFFF     (base 16)		3xLOGIC Inc.
				9882 E. 121st Street
				Fishers  IN  46037
				US

84-8B-CD   (hex)		CCX Technologies Inc.
200000-2FFFFF     (base 16)		CCX Technologies Inc.
				408 - 11 Rosemount Ave.
				Ottawa  Ontario  K1Y 4R8
				CA

84-8B-CD   (hex)		TWTG R&D B.V. 
600000-6FFFFF     (base 16)		TWTG R&D B.V. 
				Schaardijk 386
				Capelle aan den IJssel    2909LA
				NL

B0-FD-0B   (hex)		DMAC Security LLC
300000-3FFFFF     (base 16)		DMAC Security LLC
				833 Shotgun Road
				Sunrise  FL  33326
				US

B0-FD-0B   (hex)		eSenseLab Ltd.
800000-8FFFFF     (base 16)		eSenseLab Ltd.
				1 Chervena stena Str., Office 1
				Sofia  Sofia-grad  1421
				BG

B0-FD-0B   (hex)		TEMCO JAPAN CO., LTD.
A00000-AFFFFF     (base 16)		TEMCO JAPAN CO., LTD.
				2-21-4 HONAN
				SUGINAMI KU  Tokyo-to  168-0062
				JP

C8-2C-2B   (hex)		Grav I.T.
600000-6FFFFF     (base 16)		Grav I.T.
				601 1st Ave NW
				Gravette  AR  72736
				US

C8-2C-2B   (hex)		Galgus
100000-1FFFFF     (base 16)		Galgus
				Italica 1, 1st floor
				Camas  Seville  41900
				ES

C8-2C-2B   (hex)		Kunshan SVL Electric  Co.,Ltd
B00000-BFFFFF     (base 16)		Kunshan SVL Electric  Co.,Ltd
				No. 568, JuJin Road, Zhangpu Town
				SuZhou    215300
				CN

C8-2C-2B   (hex)		Merpa Bilgi Islem Ltd.Sti
700000-7FFFFF     (base 16)		Merpa Bilgi Islem Ltd.Sti
				Oztekin CD NO:26
				Istanbul  Bayrampasa  34040
				TR

E4-1E-0A   (hex)		SAGE Glass
800000-8FFFFF     (base 16)		SAGE Glass
				Two Sage Way
				Faribault  MN  55021
				US

C8-2C-2B   (hex)		UBITRON Co.,LTD
D00000-DFFFFF     (base 16)		UBITRON Co.,LTD
				Sinbuk-Ro
				Chuncheon City  Gangwon  24206
				KR

C8-63-14   (hex)		Autonics Co., Ltd.
100000-1FFFFF     (base 16)		Autonics Co., Ltd.
				4-14-26, Shimo-Muneoka
				Shiki  Saitama  3530003
				JP

C8-63-14   (hex)		Thinci, Inc.
800000-8FFFFF     (base 16)		Thinci, Inc.
				2105 S. Bascom Avenue, Suite 318
				Campbell  CA  95008
				US

C8-63-14   (hex)		Maxcom S.A.
900000-9FFFFF     (base 16)		Maxcom S.A.
				Towarowa 23A
				Tychy    43-100
				PL

FC-D2-B6   (hex)		Bee Smart(Changzhou) Information Technology Co., Ltd
D00000-DFFFFF     (base 16)		Bee Smart(Changzhou) Information Technology Co., Ltd
				Changwu Middle Road
				Changzhou  Jiangsu  213100
				CN

74-5B-C5   (hex)		CELYSS SAS
D00000-DFFFFF     (base 16)		CELYSS SAS
				7 allee des ginkgos
				Bron    69500
				FR

FC-D2-B6   (hex)		Coet Costruzioni Elettrotecniche
300000-3FFFFF     (base 16)		Coet Costruzioni Elettrotecniche
				Via Civesio 12
				San Donato Milanese  Mi  20097
				IT

A8-3F-A1   (hex)		MEDCAPTAIN MEDICAL TECHNOLOGY CO., LTD.
200000-2FFFFF     (base 16)		MEDCAPTAIN MEDICAL TECHNOLOGY CO., LTD.
				12th Floor, Baiwang Research Building, No.5158 Shahe West Road, Xili, Nanshan
				Shenzhen    518055
				CN

74-5B-C5   (hex)		Fournie Grospaud Energie SASU
A00000-AFFFFF     (base 16)		Fournie Grospaud Energie SASU
				220 rue du chene vert
				LABEGE    31670
				FR

74-5B-C5   (hex)		ComNot
C00000-CFFFFF     (base 16)		ComNot
				15 chemin des Hirondelles
				DARDILLY    69570
				FR

4C-BC-98   (hex)		Wonder Workshop
E00000-EFFFFF     (base 16)		Wonder Workshop
				1500 Fashion Island, Suite #200
				San Mateo  CA  94404
				US

4C-BC-98   (hex)		JSC NIC
100000-1FFFFF     (base 16)		JSC NIC
				Nauchny proezd, 6
				Moscow    117246
				RU

E4-4C-C7   (hex)		EPS Bio
C00000-CFFFFF     (base 16)		EPS Bio
				No. 8, R&D 3rd Rd, Science-Based Industrial Park
				Hsinchu  Taiwan  30077
				TW

E4-4C-C7   (hex)		Doowon Electronics & Telecom Co.,Ltd
200000-2FFFFF     (base 16)		Doowon Electronics & Telecom Co.,Ltd
				IT 301-408, Ssangyong 3Cha, Bucheon Technopark, 397, Seokcheon-ro, Ojeong-gu
				Bucheon-si  Gyeonggi-do  14449
				KR

E0-5A-9F   (hex)		Fibrain
600000-6FFFFF     (base 16)		Fibrain
				Zaczernie 190F
				Zaczernie  Subcarpathia  36-062
				PL

F8-02-78   (hex)		Private
F00000-FFFFFF     (base 16)		Private

4C-BC-98   (hex)		Shenzhen Cogitation Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Cogitation Technology Co.,Ltd.
				NO.509 LangShan Building,Nanshan Yungu Innovation Industrial Park,No.1183 Taoyuan Street,Nanshen District
				Shenzhen  Guangdong  518000
				CN

E0-5A-9F   (hex)		Gemalto Document Readers
900000-9FFFFF     (base 16)		Gemalto Document Readers
				3300 Acorn Street
				Williamsburg  VA  23188
				US

D8-86-0B   (hex)		Grünbeck Wasseraufbereitung GmbH
700000-7FFFFF     (base 16)		Grünbeck Wasseraufbereitung GmbH
				Josef-Grünbeck-Str. 1
				Hoechstaedt a.d. Donau    89420
				DE

D8-86-0B   (hex)		Inspur Group Co., Ltd.
000000-0FFFFF     (base 16)		Inspur Group Co., Ltd.
				No.1036 Langchao Rd.
				Jinan  Shandong  250101
				CN

D8-86-0B   (hex)		CAMTRACE
500000-5FFFFF     (base 16)		CAMTRACE
				26 BIS BOULEVARD HENRI SELLIER
				SURESNES    92150
				FR

38-B1-9E   (hex)		System Q Ltd
B00000-BFFFFF     (base 16)		System Q Ltd
				Turnoaks Business Park, Hasland
				Chesterfield  Derbyshire  S40 2WB
				GB

CC-D3-9D   (hex)		Ethernity Networks
D00000-DFFFFF     (base 16)		Ethernity Networks
				Ha-Melacha 13
				Lod  Israel  7152025
				IL

CC-D3-9D   (hex)		SHENZHEN ROYOLE TECHNOLOGIES CO., LTD.
500000-5FFFFF     (base 16)		SHENZHEN ROYOLE TECHNOLOGIES CO., LTD.
				Building #43, Dayun Software Town, No.8288 Longgang Road, Henggang Street, Longgang District,
				Shenzhen  Guangdong  518000
				CN

D4-25-CC   (hex)		Barobo, Inc.
400000-4FFFFF     (base 16)		Barobo, Inc.
				221 G Street, #204
				Davis  CA  95616
				US

9C-69-B4   (hex)		BEIJING PICOHOOD TECHNOLOGY CO.,LTD
A00000-AFFFFF     (base 16)		BEIJING PICOHOOD TECHNOLOGY CO.,LTD
				Room 504A, Building E, Lize Middle Yard, Wangjing Science and Technology Venture Park, Chaoyang District
				BEIJING  BEIJING  100102
				CN

9C-69-B4   (hex)		Elesta GmbH
500000-5FFFFF     (base 16)		Elesta GmbH
				Heuteilstrasse 18
				Bad Ragaz  St. Gallen  7310
				CH

9C-69-B4   (hex)		Toughdog Security Systems
B00000-BFFFFF     (base 16)		Toughdog Security Systems
				1317 E Hackberry Ave
				McAllen  TX  78501
				US

6C-DF-FB   (hex)		Chongqing Baoli Yota Technologies Limited
100000-1FFFFF     (base 16)		Chongqing Baoli Yota Technologies Limited
				No.2,1 Floor,Kelly Building,No.115 Xingtong Avenue,Guilin Street office, Tongnan District
				Chongqing  Chongqing  402660
				CN

A4-4F-29   (hex)		Private
F00000-FFFFFF     (base 16)		Private

4C-91-7A   (hex)		Chongqing Unisinsight Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Chongqing Unisinsight Technology Co.,Ltd.
				No.117-386, Yunhan Road
				Beibei District  Chongqing  400714
				CN

4C-91-7A   (hex)		Shenzhen bankledger Technology Co, Ltd
D00000-DFFFFF     (base 16)		Shenzhen bankledger Technology Co, Ltd
				Room 802, Tower A, Yuanzheng Venture Building, No. 19 Langshan Road, Nanshan District
				Shenzhen     518000
				CN

6C-DF-FB   (hex)		Beijing Fimi Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Beijing Fimi Technology Co., Ltd.
				Room 348, 3F, Complex building A1, Yongtai Park, Qinghe Street, Haidian District, Beijing
				Beijing    100000
				CN

6C-DF-FB   (hex)		Beijing Ainemo Co Ltd
300000-3FFFFF     (base 16)		Beijing Ainemo Co Ltd
				Building K1,  NO. 86 Beiyuan North road, Chaoyang district, Beijing China
				Beijing   Beijing  100012
				CN

4C-91-7A   (hex)		Shenzhen Dangs Science & Technology CO.,LTD
000000-0FFFFF     (base 16)		Shenzhen Dangs Science & Technology CO.,LTD
				7D, 7th Floor, HSAE Building, Nanshan District,
				Shenzhen  GuangDong  518000
				CN

7C-BC-84   (hex)		Nanning auto digital technology co.,LTD
500000-5FFFFF     (base 16)		Nanning auto digital technology co.,LTD
				3/f, no.6 guichun road, qingxiu district
				Nanning  Guangxi  530021
				CN

98-F9-C7   (hex)		Koala Technology CO., LTD.
900000-9FFFFF     (base 16)		Koala Technology CO., LTD.
				Room 2004, Building A3, Dayuan International Center, High Tech Zone
				Chengdu  Sichuan  610000
				CN

6C-DF-FB   (hex)		Hashtrend AG
700000-7FFFFF     (base 16)		Hashtrend AG
				Bahnhofstrasse
				Zug    6300
				CH

98-F9-C7   (hex)		GoodBox
600000-6FFFFF     (base 16)		GoodBox
				Ground Floor, Optimum House
				Clippers Quay  Salford Quays  M50 3XP
				GB

98-F9-C7   (hex)		Tonycore Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Tonycore Technology Co.,Ltd.
				2/F,Building A,Dingxin Technology Park,Honglang North 2nd Road,Xin’an Street,Bao’an District,
				Shenzhen  Guangdong  518000
				CN

98-F9-C7   (hex)		hangzhou soar security technologies limited liability company
D00000-DFFFFF     (base 16)		hangzhou soar security technologies limited liability company
				Zhebao Ideal Xiangyuan Creative industrial Park
				Hangzhou  Zhejiang  Zhejiang
				CN

2C-48-35   (hex)		IROOTECH TECHNOLOGY CO.,LTD
E00000-EFFFFF     (base 16)		IROOTECH TECHNOLOGY CO.,LTD
				Room 606, Floor 6, Building 5, Eastern Yard 10, Xibeiwang East Road
				Beijing    100092
				CN

0C-FE-5D   (hex)		NEWGREEN TECH CO., LTD.
E00000-EFFFFF     (base 16)		NEWGREEN TECH CO., LTD.
				2F., No.200, Sec. 2, Gaotie N. Rd., Dayuan Dist., Taoyuan City 337, Taiwan (R.O.C.)
				Taoyuan City    33743
				TW

0C-FE-5D   (hex)		Bepal Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Bepal Technology Co.,Ltd.
				Xihu Qu, Tianmushan Road, Qianjiang Xixi Xinzuo
				HangZhou  ZheJiang  310000
				CN

3C-39-E7   (hex)		Private
F00000-FFFFFF     (base 16)		Private

0C-FE-5D   (hex)		Chengdu Ledong Information & Technology Co., Ltd. 
000000-0FFFFF     (base 16)		Chengdu Ledong Information & Technology Co., Ltd. 
				D7-13F, Chengdu Tianfu Software Park, No. 599 Shijicheng South street, Gaoxin District, Chengdu, China
				Chengdu  sichaun  610041
				CN

6C-5C-3D   (hex)		GUANGZHOU GUANGRI ELEVATOR INDUSTRY CO.,LTD
800000-8FFFFF     (base 16)		GUANGZHOU GUANGRI ELEVATOR INDUSTRY CO.,LTD
				636 South of Guomao Road,Shilou County,Panyu District
				Guangzhou  Guangdong  511047
				CN

6C-5C-3D   (hex)		ShenZhen Hugsun Technology Co.,Ltd.
000000-0FFFFF     (base 16)		ShenZhen Hugsun Technology Co.,Ltd.
				413~415 Room, 4/F, No.6 Bldg., TongFuYu Industrial Park, Dalang Street, 518109, Longhua New District,
				ShengZhen  GuangDong  518109
				CN

6C-5C-3D   (hex)		Unitel Engineering
500000-5FFFFF     (base 16)		Unitel Engineering
				2-я Кабельная д.2 стр.1
				Москва  Россия  111024
				RU

A8-3F-A1   (hex)		BEGLEC
600000-6FFFFF     (base 16)		BEGLEC
				hofveld 2c
				Groot-Bijgaarden    1702
				BE

1C-FD-08   (hex)		ShenZhen DeLippo Technology Co., LTD
800000-8FFFFF     (base 16)		ShenZhen DeLippo Technology Co., LTD
				District A of Fifth Floor,Building E,Guancheng Low Carbon Industrial Park, Shangcun Community,Gongming Street,Guangming District
				Shenzhen    518106
				CN

A8-3F-A1   (hex)		Neos Ventures Limited
800000-8FFFFF     (base 16)		Neos Ventures Limited
				47 Bermondsey Street
				London    SE1 3XT
				GB

A8-3F-A1   (hex)		GTDevice LLC
100000-1FFFFF     (base 16)		GTDevice LLC
				PO BOX 86339
				Portland  OR  97286
				US

E8-18-63   (hex)		Private
F00000-FFFFFF     (base 16)		Private

3C-6A-2C   (hex)		TP Radio
800000-8FFFFF     (base 16)		TP Radio
				Agenavej 37
				Greve  .  2670
				DK

3C-6A-2C   (hex)		Xiamen Smarttek CO., Ltd.
D00000-DFFFFF     (base 16)		Xiamen Smarttek CO., Ltd.
				5F, B Area, Chuangxin Plaza, SoftPark I, Siming District
				Xiamen  Fujian  361005
				CN

3C-6A-2C   (hex)		Eltov System
C00000-CFFFFF     (base 16)		Eltov System
				#1309 Gyeonggi Venture Yeonsung Univ Center. 111, Anyang-ro, Manan-gu,
				Anyang-si    14093
				KR

3C-6A-2C   (hex)		Metro
A00000-AFFFFF     (base 16)		Metro
				189 rue de la Jonchere
				Boege    74420
				FR

3C-6A-2C   (hex)		Olibra LLC
100000-1FFFFF     (base 16)		Olibra LLC
				45 legin dr
				creskill  NJ  07626
				US

3C-6A-2C   (hex)		XI'AN YEP TELECOM TECHNOLOGY CO.,LTD
400000-4FFFFF     (base 16)		XI'AN YEP TELECOM TECHNOLOGY CO.,LTD
				5F,Building C,CLP Park,No.211, Tiangu 8 Road, High-tech Zone, Xi' an, Shanxi Province, China
				Xi’an  Shanxi   710001
				CN

A4-ED-43   (hex)		Wuxi Junction Infomation Technology Incorporated Company
700000-7FFFFF     (base 16)		Wuxi Junction Infomation Technology Incorporated Company
				ROOM919,NO.401 XINGYUANBEILU ROAD, LIANGXI DISTRIC,WUXI CITY,JIANGSU PROVINCE
				WuXi  Jiangsu  214000
				CN

30-0A-60   (hex)		Ampetronic Ltd
A00000-AFFFFF     (base 16)		Ampetronic Ltd
				Unit 2 Trentside Business Village, Farndon Road
				Newark  Nottinghamshire  NG24 4XB
				GB

30-0A-60   (hex)		WINTEK System Co., Ltd
900000-9FFFFF     (base 16)		WINTEK System Co., Ltd
				Wintek Venture Bldg., 511, Poil-Dong
				Uiwang-City  Gyunggi-Do  16013
				KR

30-0A-60   (hex)		Giax GmbH
B00000-BFFFFF     (base 16)		Giax GmbH
				Am Weichselgarten 7
				Erlangen    91058
				DE

30-0A-60   (hex)		Thermo Process Instruments, LP
C00000-CFFFFF     (base 16)		Thermo Process Instruments, LP
				27 Forge Parkway
				Frankllin  MA  02038
				US

A0-28-33   (hex)		Xiamen Caimore Communication Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Xiamen Caimore Communication Technology Co.,Ltd.
				 #2 of 302 Unit, 23# Wanghai Road, Xiamen Software Park II
				Xiamen  Fujian  361009
				CN

A0-28-33   (hex)		GERSYS GmbH
000000-0FFFFF     (base 16)		GERSYS GmbH
				Hans-Urmiller-Ring 12A
				Wolfratshausen    82515
				DE

A4-ED-43   (hex)		Brand New Brand Nordic AB
D00000-DFFFFF     (base 16)		Brand New Brand Nordic AB
				Nohrstedts väg 5
				Söderbärke    77794
				SE

A4-ED-43   (hex)		Linseis Messgeraete GmbH
800000-8FFFFF     (base 16)		Linseis Messgeraete GmbH
				Vielitzer Str. 43                      
				Selb    95100
				DE

A0-28-33   (hex)		Audix
D00000-DFFFFF     (base 16)		Audix
				9400 SW Barber St. 
				Wilsonville  OR  97070
				US

A0-28-33   (hex)		Shanghai Nohmi Secom Fire Protection  Equipment Co.,Ltd.
200000-2FFFFF     (base 16)		Shanghai Nohmi Secom Fire Protection  Equipment Co.,Ltd.
				No.98,Lane 1971,(s)Lianhua Road,Minhang Area
				Shanghai  Shanghai  201108
				CN

84-89-EC   (hex)		Shenzhen Intellifusion Technologies Co., Ltd.
E00000-EFFFFF     (base 16)		Shenzhen Intellifusion Technologies Co., Ltd.
				Suite701, Science Museum, Shenzhen City
				Shenzhen  Guangdong  518000
				CN

00-55-DA   (hex)		Victorsure Limited
E00000-EFFFFF     (base 16)		Victorsure Limited
				15/F Cambridge house, 26-28 Cameron Road
				Hong Kong  Hong Kong  Hong Kong
				HK

84-89-EC   (hex)		Research Electronics International, LLC.
100000-1FFFFF     (base 16)		Research Electronics International, LLC.
				455 Secuity Drive
				Cookeville  TN  38506
				US

30-09-F9   (hex)		OOO Microlink-Svyaz
300000-3FFFFF     (base 16)		OOO Microlink-Svyaz
				1st veshnjakovsky proezd 7
				moscow   moscow   109456
				RU

84-89-EC   (hex)		Arts Digital Technology (HK) Ltd.
800000-8FFFFF     (base 16)		Arts Digital Technology (HK) Ltd.
				1704, 17/F, Fo Tan Industrial Centre, 26-28 Au Pui Wan Street, Fo Tan, Hong Kong
				Hong Kong    Nil
				HK

84-89-EC   (hex)		Vayyar Imaging Ltd.
400000-4FFFFF     (base 16)		Vayyar Imaging Ltd.
				3 Avraham Giron St
				Yehud    5621717
				IL

84-89-EC   (hex)		POCT biotechnology
600000-6FFFFF     (base 16)		POCT biotechnology
				6F, No. 185, GangQian Rd., Neihu dist.,
				Taipei    11494
				TW

30-09-F9   (hex)		Technology for Humankind
D00000-DFFFFF     (base 16)		Technology for Humankind
				3913 N. Rushwood St.
				Wichita  KS  67226
				US

C0-83-59   (hex)		SHANGHAI CHARMHOPE INFORMATION TECHNOLOGY CO.,LTD.
A00000-AFFFFF     (base 16)		SHANGHAI CHARMHOPE INFORMATION TECHNOLOGY CO.,LTD.
				Building 11,No.230,Chuanhong Rd,Pudong Distrist
				Shanghai  Shanghai  201202
				CN

9C-F6-DD   (hex)		Ithor IT Co.,Ltd.
100000-1FFFFF     (base 16)		Ithor IT Co.,Ltd.
				No. 501, Building I, ZTE Park, Hi-Tech Industrial Zone
				XI'AN  ShanXi  710065
				CN

9C-F6-DD   (hex)		Guangzhou LANGO Electronics Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Guangzhou LANGO Electronics Technology Co., Ltd.
				136#, Gaopu Road, Tianhe District
				Guangzhou  Guangdong  510663
				CN

9C-F6-DD   (hex)		CAMA（Luoyang）Electronics Co.，Ltd
900000-9FFFFF     (base 16)		CAMA（Luoyang）Electronics Co.，Ltd
				Luoyang High-tech District, Chuncheng Road 16th.
				Luoyang  Henan  471003
				CN

C0-83-59   (hex)		Suzhou Siheng Science and Technology Ltd.
B00000-BFFFFF     (base 16)		Suzhou Siheng Science and Technology Ltd.
				8 floor of Jincheng star, Yunhe road NO.150, gaoxin Zone, Suzhou
				Suzhou    215000
				CN

C0-83-59   (hex)		ista International GmbH
800000-8FFFFF     (base 16)		ista International GmbH
				Luxemburger Strasse 1
				Essen  NRW  45131
				DE

C0-83-59   (hex)		Fuzhou Fdlinker Technology Co.,LTD
700000-7FFFFF     (base 16)		Fuzhou Fdlinker Technology Co.,LTD
				28th floor, Building 1, area F, Fuzhou software park, 89 Ruanjian Avenue
				Fuzhou  Fujian  350001
				CN

04-C3-E6   (hex)		Teleepoch Ltd
E00000-EFFFFF     (base 16)		Teleepoch Ltd
				No.13 Langshan Rd,HiTech Park,Nanshan District
				Shenzhen  Guangdong  518000
				CN

04-C3-E6   (hex)		Sealed Unit Parts Co., Inc.
A00000-AFFFFF     (base 16)		Sealed Unit Parts Co., Inc.
				2230 Landmark Place
				ALLENWOOD  NJ  08720
				US

C0-83-59   (hex)		PCH Engineering A/S
300000-3FFFFF     (base 16)		PCH Engineering A/S
				Ved Klaedebo 4
				Horsholm    2970
				DK

B4-4B-D6   (hex)		DongYoung media
B00000-BFFFFF     (base 16)		DongYoung media
				#18, Dangjeong-Ro, Gunpo-Si,
				Gyeonggi-Do,    15849
				KR

B4-4B-D6   (hex)		Perspicace Intellegince Technology
600000-6FFFFF     (base 16)		Perspicace Intellegince Technology
				4F, 1326#, West YanAn road, Shanghai, P.R.China
				ShangHai  ShangHai  200052
				CN

3C-42-7E   (hex)		Shenzhen VETAS Communication Technology Co , Ltd.
300000-3FFFFF     (base 16)		Shenzhen VETAS Communication Technology Co , Ltd.
				Room 1301-1303,West Wing,Skyworth Semiconductor Design Building,No.18,Gaoxin South 4th road, Nanshan District
				ShenZhen  Guangdong  518063
				CN

3C-42-7E   (hex)		Privacy Labs
C00000-CFFFFF     (base 16)		Privacy Labs
				10400 NE 4th Street, 7th Floor
				Bellevue  WA  98004
				US

3C-42-7E   (hex)		Starloop Tech Co., Ltd.
200000-2FFFFF     (base 16)		Starloop Tech Co., Ltd.
				#643, Meinian Plaza A
				Chengdu    610000
				CN

3C-42-7E   (hex)		Geoplan Korea
500000-5FFFFF     (base 16)		Geoplan Korea
				Simin-ro 327-7 DaeMyung Bldg #614
				AnYang    15044
				KR

B4-4B-D6   (hex)		Huizhou Sunoda Technology Co. Ltd
300000-3FFFFF     (base 16)		Huizhou Sunoda Technology Co. Ltd
				NO.4 XING JU WEST ROAD,DONG XING DISTRICT,ZHONG KAI DONG JIANG HIGH TECHNOLOGY INDUSTRIAL PARK,
				HUI ZHOU  guangdong  516000
				CN

B4-4B-D6   (hex)		Shenzhen Hi-Net Technology Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen Hi-Net Technology Co., Ltd.
				3F, 4Building, Anda Industrial Zone, Chongqing Road, Fuyong Town, Baoan District
				ShenZhen  GuangDong  518103
				CN

B4-4B-D6   (hex)		Taizhou convergence Information technology Co.,LTD
700000-7FFFFF     (base 16)		Taizhou convergence Information technology Co.,LTD
				Room 1006,general chamber of commerce,159 henghu road
				wenling  zhejiang  317515
				CN

B4-4B-D6   (hex)		G4S Monitoring Technologies Ltd
000000-0FFFFF     (base 16)		G4S Monitoring Technologies Ltd
				3 Centurion Court, Meridian East
				Leicester  Leicestershire  LE19 1TP
				GB

D4-7C-44   (hex)		SHENZHEN ANYSEC TECHNOLOGY CO. LTD
E00000-EFFFFF     (base 16)		SHENZHEN ANYSEC TECHNOLOGY CO. LTD
				601, 1 BUILDING,MeiLin Dolly Industrial Zone,Futian District
				SHENZHEN  GuangDong  518000
				CN

D4-7C-44   (hex)		Pongee Industries Co., Ltd.
700000-7FFFFF     (base 16)		Pongee Industries Co., Ltd.
				5F., No.738, Chung-Cheng Road,
				Chung-Ho District,  New Taipei City,   23511
				TW

A0-19-B2   (hex)		ARIMA Communications Corp.
700000-7FFFFF     (base 16)		ARIMA Communications Corp.
				6F.,No.866,Zhongzheng Rd.,Zhonghe Dist.,
				New Taipei City  Taiwan  23586
				TW

A0-19-B2   (hex)		GfG mbH
600000-6FFFFF     (base 16)		GfG mbH
				Kloennestrasse 99
				Dortmund    44143
				DE

1C-A0-D3   (hex)		Exicom Tele-Systems Ltd.
E00000-EFFFFF     (base 16)		Exicom Tele-Systems Ltd.
				Plot Number 77A, IFFCO Road, Sector 18
				Gurgaon  Haryana  122015
				IN

A0-19-B2   (hex)		HangZhou iMagic Technology Co., Ltd 
B00000-BFFFFF     (base 16)		HangZhou iMagic Technology Co., Ltd 
				Block F, 11th Floor, Building A, Tiantang Software Park, 3# Xidoumen Road, 
				Hangzhou  Zhejiang  310012
				CN

A0-19-B2   (hex)		RYD Electronic Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		RYD Electronic Technology Co.,Ltd.
				Room1602,No68 Taidong Road,Siming District,Xiamen City
				Xiamen  FuJian  361000
				CN

D4-7C-44   (hex)		STRIVE ORTHOPEDICS INC
C00000-CFFFFF     (base 16)		STRIVE ORTHOPEDICS INC
				505 PARK AVE FL 17
				NEW YORK  NY  10022
				US

D4-7C-44   (hex)		OPTiM Corporation
B00000-BFFFFF     (base 16)		OPTiM Corporation
				1 Honjo-machi
				Saga    840-8502
				JP

2C-48-35   (hex)		Phasor Solutions Ltd
D00000-DFFFFF     (base 16)		Phasor Solutions Ltd
				The Record Hall, 16 Baldwin Gardens
				London    EC1N 7RJ
				GB

2C-48-35   (hex)		FAST
700000-7FFFFF     (base 16)		FAST
				4740 44th Ave SW Suite #201
				Seattle  WA  98116
				US

3C-24-F0   (hex)		Swissdotnet SA
700000-7FFFFF     (base 16)		Swissdotnet SA
				Route Saint-Nicolas-de-Flüe 2
				Fribourg    1700
				CH

0C-73-EB   (hex)		U-PASS.CO.,LTD
400000-4FFFFF     (base 16)		U-PASS.CO.,LTD
				HANEULMAEUL-RO 
				GYEONGGI-DO  GOYANG-SI,ILSANDONG-GU  410315
				KR

48-0B-B2   (hex)		Microprogram Information Co., Ltd
900000-9FFFFF     (base 16)		Microprogram Information Co., Ltd
				14F., No.262, Sec. 2, Henan Rd., Xitun Dist.
				Taichung    407
				TW

48-0B-B2   (hex)		Hangzhou Freely Communication Co., Ltd.
400000-4FFFFF     (base 16)		Hangzhou Freely Communication Co., Ltd.
				No. 90 Wensan, Hangzhou, Zhejiang
				Hangzhou   Zhejiang  310012
				CN

48-0B-B2   (hex)		BravoCom（xiamen）TechCo.Ltd
800000-8FFFFF     (base 16)		BravoCom（xiamen）TechCo.Ltd
				Room 506, Chengye Building lnnovation park Xiamen Torch Hi-Tech Zone Xiamen fujian P.R.China
				Xiamen  fujian  361000
				CN

48-0B-B2   (hex)		SHENZHEN TOPWELL TECHNOLOGY CO..LTD
C00000-CFFFFF     (base 16)		SHENZHEN TOPWELL TECHNOLOGY CO..LTD
				5th Floor, Building 10 Changyuan New Material 
				Port,No.2,Middle Road 1, High Tech Park,  Nanshan District,Shenzhen  518001
				CN

88-5F-E8   (hex)		Changsha Xiangji-Haidun Technology Co., Ltd
800000-8FFFFF     (base 16)		Changsha Xiangji-Haidun Technology Co., Ltd
				NO.5 Dongsan Rd, Changsha Economic & Technical Zone
				Changsha  HuNan  410100
				CN

30-1F-9A   (hex)		Smart Component Technologies LTD
B00000-BFFFFF     (base 16)		Smart Component Technologies LTD
				Cooper Buildings, Arundel Street
				Sheffield  South Yorkshire  S1 2NS
				GB

30-1F-9A   (hex)		CHISON Medical Technologies Co., Ltd.
200000-2FFFFF     (base 16)		CHISON Medical Technologies Co., Ltd.
				No.9, Xinhuihuan Road, Xinwu District, Wuxi, Jiangsu, China 214028
				WUXI  JIANGSU  214028
				CN

88-5F-E8   (hex)		Shenzhen ORVIBO Technology Co., Ltd
B00000-BFFFFF     (base 16)		Shenzhen ORVIBO Technology Co., Ltd
				7F, A7 Zhiyuan, No.1001, Xueyuan AV., Nanshan district, Shenzhen,518055,PRC
				 Shenzhen  guangdong  518000
				CN

88-5F-E8   (hex)		Apoidea Technology Co., Ltd.
100000-1FFFFF     (base 16)		Apoidea Technology Co., Ltd.
				No. 111, Boyun Road
				Shanghai    201203
				CN

F0-41-C8   (hex)		ATN Media Group FZ LLC
D00000-DFFFFF     (base 16)		ATN Media Group FZ LLC
				Business Bay-alabrj st Business Towar By Damac.office-807
				Dubai    25051
				AE

F0-41-C8   (hex)		Telstra
A00000-AFFFFF     (base 16)		Telstra
				231 Elisabeth St
				SYDNEY  NSW  2000
				AU

88-A9-A7   (hex)		Shenzhenshi kechuangzhixian technology Co.LTD
000000-0FFFFF     (base 16)		Shenzhenshi kechuangzhixian technology Co.LTD
				Room 14G,14th Floor, Langshi Building , keji South Road 12 , High-tech Industrial Park , Nanshan District
				Shenzhen    518000
				CN

88-A9-A7   (hex)		Volterman Inc.
500000-5FFFFF     (base 16)		Volterman Inc.
				Suite B2, Sunset Lake Road
				Newark  DE  19702
				US

88-A9-A7   (hex)		AVLINK INDUSTRIAL CO., LTD
D00000-DFFFFF     (base 16)		AVLINK INDUSTRIAL CO., LTD
				7/F, A1 Bldg, 1st Shuichanjingwan Industrial Park, Nanchang Village, Gushu, Bao'an Dist 
				Shenzhen  Guangdong  518126
				CN

F0-41-C8   (hex)		DongGuan Siyoto Electronics Co., Ltd       
100000-1FFFFF     (base 16)		DongGuan Siyoto Electronics Co., Ltd       
				Hecheng Industrial District, QiaoTou Town
				DongGuan City  Guangdong  523520
				CN

F0-41-C8   (hex)		Candelic Limited
400000-4FFFFF     (base 16)		Candelic Limited
				Unit 312, 3/F Solo Workshop, 131-132 Cannaught Road West
				Hong Kong    111111
				HK

A4-DA-22   (hex)		Shen Zhen City YaKun Electronics Co., Ltd
D00000-DFFFFF     (base 16)		Shen Zhen City YaKun Electronics Co., Ltd
				SOUTHERN BUILDING 5388 Shang Bu  Industrial Zone Huaqiang North Road Futian District
				shen zhen city  Guang Dong Province  518000
				CN

A4-DA-22   (hex)		Klashwerks Inc.
B00000-BFFFFF     (base 16)		Klashwerks Inc.
				441 Maclaren Street, Suite 408
				Ottawa  ON  K2P2H3
				CA

A4-DA-22   (hex)		Hydro Electronic Devices, Inc.
700000-7FFFFF     (base 16)		Hydro Electronic Devices, Inc.
				2120 Constitution Ave
				Hartford  WI  53027
				US

A4-DA-22   (hex)		DURATECH Enterprise,LLC
300000-3FFFFF     (base 16)		DURATECH Enterprise,LLC
				NO.1013,184,Gasan digital 2-ro,Geumcheon-gu,Seoul
				Seoul    08501
				KR

A4-DA-22   (hex)		LORIOT AG
400000-4FFFFF     (base 16)		LORIOT AG
				Zuercherstrasse 68
				Thalwil  Zürich  8800
				CH

A4-DA-22   (hex)		T2T System
100000-1FFFFF     (base 16)		T2T System
				#316, HYUNDAI Knowledge Industry Center, 70, Dusan-ro
				Geumcheon-gu  Seoul  08584
				KR

A4-DA-22   (hex)		Original Products Pvt. Ltd.
500000-5FFFFF     (base 16)		Original Products Pvt. Ltd.
				B-19, Shiv Park, School Road, Khanpur 
				New Delhi  New Delhi  110062
				IN

DC-E5-33   (hex)		Tintel Hongkong Co.Ltd
B00000-BFFFFF     (base 16)		Tintel Hongkong Co.Ltd
				FLAT C,23/F,LUCKY PLAZA,315-321 LOCKHART ROAD,WANCHAI,HONGKONG
				HONGKONG  GUANG DONG PROVINCE  999077
				HK

DC-E5-33   (hex)		JB-Lighting Lichtanlagen GmbH
800000-8FFFFF     (base 16)		JB-Lighting Lichtanlagen GmbH
				Sallersteig 15
				89134    89134
				DE

C4-FF-BC   (hex)		GSM Innovations Pty Ltd
900000-9FFFFF     (base 16)		GSM Innovations Pty Ltd
				142-144 Fullarton Road
				Rose Park  SA  5067
				AU

DC-E5-33   (hex)		Remko GmbH & Co. KG
200000-2FFFFF     (base 16)		Remko GmbH & Co. KG
				Im Seelenkamp 12
				Lage    32791
				DE

DC-E5-33   (hex)		Ambi Labs Limited
100000-1FFFFF     (base 16)		Ambi Labs Limited
				1903, 19/F, Loon Lee Building, 267-275 Des Voeux Road Central., Sheung Wan, Hong Kong
				Hong Kong  Hong Kong  00000
				HK

C4-FF-BC   (hex)		comtime GmbH
500000-5FFFFF     (base 16)		comtime GmbH
				Gutenbergring 22
				Norderstedt    22848
				US

C4-FF-BC   (hex)		VISATECH C0., LTD.
100000-1FFFFF     (base 16)		VISATECH C0., LTD.
				C-312 168, Gasan digital 1-ro
				 Geumcheon-gu   Seoul  08507
				KR

1C-21-D1   (hex)		p2-plus inc.
E00000-EFFFFF     (base 16)		p2-plus inc.
				12F.-6,No.5,Sec.3,new taipei Blvd., Sinjhuang Dist.,
				new taipei  taiwan  24250
				TW

34-29-8F   (hex)		Albert Handtmann Maschinenfabrik GmbH&Co.KG
C00000-CFFFFF     (base 16)		Albert Handtmann Maschinenfabrik GmbH&Co.KG
				Hubertus-Liebrecht-Str. 10-12
				Biberach    88400
				DE

9C-43-1E   (hex)		HK ELEPHONE Communication Tech Co.,Limited
D00000-DFFFFF     (base 16)		HK ELEPHONE Communication Tech Co.,Limited
				Unit 04, 7/F Bright Way Tower No.33 Mong Kok Rd KL
				Hong Kong     999077
				HK

28-2C-02   (hex)		Tokin Limited
A00000-AFFFFF     (base 16)		Tokin Limited
				Unit 513-4, Block A, Focal Industrial Centre, 21 Man Lok Street, Hung Hom
				Kowloon    0000
				HK

28-2C-02   (hex)		LLC MICROTEH
500000-5FFFFF     (base 16)		LLC MICROTEH
				pl.5 bldg.2/3 Akademika Anokhina str. 
				Moscow    119602
				RU

28-2C-02   (hex)		ThirdReality, Inc
B00000-BFFFFF     (base 16)		ThirdReality, Inc
				647 East Longhua Road, Huangpu District
				Shanghai  Shanghai  200023
				CN

9C-43-1E   (hex)		Antailiye Technology Co.,Ltd
000000-0FFFFF     (base 16)		Antailiye Technology Co.,Ltd
				7/F,Zhengjiyuan Buiding,2 Road,Qianjing, Xixiang, Baoan District,Shenzhen
				SHEN ZHEN  GUANGDONG  518000
				CN

F8-B5-68   (hex)		Dongwoo Engineering Co.,Ltd
300000-3FFFFF     (base 16)		Dongwoo Engineering Co.,Ltd
				#311, dREC Techno 9-ro, Yuseong-gu
				Daegeon    34027
				KR

F8-B5-68   (hex)		LifePrint Products, Inc.
000000-0FFFFF     (base 16)		LifePrint Products, Inc.
				4667 Golden Foothill Parkway, Suite 102
				El Dorado Hills  CA  95762
				US

F8-B5-68   (hex)		etectRx
500000-5FFFFF     (base 16)		etectRx
				107 SW 140th Terr., Ste. 1
				Newberry  FL  32669
				US

F8-B5-68   (hex)		Combiwins Technology Co.,Limited
400000-4FFFFF     (base 16)		Combiwins Technology Co.,Limited
				2F Sever Star Mansion, West Qixing Road 
				Xiamen  Fujian  361012
				CN

28-2C-02   (hex)		SAKATA DENKI Co., Ltd.
000000-0FFFFF     (base 16)		SAKATA DENKI Co., Ltd.
				Yagisawa2-17-20
				NishiTokyo-city  Tokyo  202-0022
				JP

38-73-EA   (hex)		Annapurna labs
D00000-DFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

38-73-EA   (hex)		Shenzhen Jixian Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Shenzhen Jixian Technology Co., Ltd.
				4F, Building A, Tongfang Information Harbor, No.11, Langshan Road, North Area of High-tech Park, Nanshan District
				Shenzhen  Guangdong  518000
				CN

40-48-FD   (hex)		Plus One Global Ltd.
900000-9FFFFF     (base 16)		Plus One Global Ltd.
				2-8-6,Nishishinbashi
				Minato-ku  Tokyo  105-0003
				JP

38-73-EA   (hex)		PingGPS Inc
700000-7FFFFF     (base 16)		PingGPS Inc
				19825 North Cove Road, #173
				CORNELIUS  NC  28031
				US

38-73-EA   (hex)		SHENZHEN CSE TECHNOLOGY CO., LTD
A00000-AFFFFF     (base 16)		SHENZHEN CSE TECHNOLOGY CO., LTD
				2F,3Building,Xinlianhe Industrial Park,Jinxiu Road,Western Industrial Zone, Shajing Town,Baoan,
				Shenzhen  Guangdong  518000
				CN

38-73-EA   (hex)		Proch plastic Co., Ltd.
300000-3FFFFF     (base 16)		Proch plastic Co., Ltd.
				7F No.189 Xinhu 3rd Rd. Neihu Dist.
				Taipei city  ---  114
				TW

38-73-EA   (hex)		LG Electronics
C00000-CFFFFF     (base 16)		LG Electronics
				51, Gasan Digital1-ro, Geumcheon-gu
				Seoul    08592
				KR

34-D0-B8   (hex)		Captec Ltd
000000-0FFFFF     (base 16)		Captec Ltd
				7 Whittle Avenue
				Fareham  Hampshire  PO15 5SH
				GB

8C-14-7D   (hex)		Anyware Solutions ApS
900000-9FFFFF     (base 16)		Anyware Solutions ApS
				Monrads Alle 9
				Valby  Sjaelland  2500
				DK

34-D0-B8   (hex)		Meatest sro
A00000-AFFFFF     (base 16)		Meatest sro
				Zelezna 509/3
				Brno    61900
				CZ

EC-9F-0D   (hex)		WisIOE
400000-4FFFFF     (base 16)		WisIOE
				Room 601, Hongyuan Building, Baoyuan Road, Xixiang Street, Baoan District 
				Shenzhen  Guangdong  518000
				CN

AC-1D-DF   (hex)		Elekon AG
D00000-DFFFFF     (base 16)		Elekon AG
				Cheerstrasse 16
				Luzern    6014
				CH

AC-1D-DF   (hex)		HellaStorm, Inc.
100000-1FFFFF     (base 16)		HellaStorm, Inc.
				12655 Edison Drive, Suite 250
				Alpharetta  GA  30005
				US

AC-1D-DF   (hex)		WESCO INTEGRATED SUPPLY
A00000-AFFFFF     (base 16)		WESCO INTEGRATED SUPPLY
				36 HARBOR PARK DRIVE
				PORT WASHINGTON  NY  11050
				US

74-1A-E0   (hex)		FUJIAN TAILI COMMUNICATION TECHNOLOGY CO.,LTD
500000-5FFFFF     (base 16)		FUJIAN TAILI COMMUNICATION TECHNOLOGY CO.,LTD
				Cangshan science and technology park, Baihuting,Cangshan District, Fuzhou
				FUZHOU    350026
				CN

74-1A-E0   (hex)		NURA HOLDINGS PTY LTD
200000-2FFFFF     (base 16)		NURA HOLDINGS PTY LTD
				349 Brunswick Rd
				Brunswick  VIC  3056
				AU

74-1A-E0   (hex)		bistos.co.ltd
C00000-CFFFFF     (base 16)		bistos.co.ltd
				7floor, worim lions vally 5cha
				sungnam  kyeunggi-do  13201
				KR

74-1A-E0   (hex)		Huano International Technology Limited
000000-0FFFFF     (base 16)		Huano International Technology Limited
				Room 402, Building A, ChuangXin Technology Plaza(Phase 1),Chegongmiao, Futian District, 
				Shenzhen    518000
				CN

74-1A-E0   (hex)		Revl Inc.
400000-4FFFFF     (base 16)		Revl Inc.
				325 9th St.
				San Francisco  CA  94103
				US

CC-22-37   (hex)		Terma Sp. z o.o.
100000-1FFFFF     (base 16)		Terma Sp. z o.o.
				Czaple 100
				Gdańsk  Pomorskie  80-298
				PL

2C-27-9E   (hex)		Rutledge Omni Services Pte Ltd
600000-6FFFFF     (base 16)		Rutledge Omni Services Pte Ltd
				34 Toh Guan Road East, #01-12/13 Enterprise Hub
				Singapore  Singapore  608579
				SG

2C-27-9E   (hex)		Forties Inc.
B00000-BFFFFF     (base 16)		Forties Inc.
				5-3-10-1F, Shiba
				Minato  Tokyo  1080014
				JP

2C-27-9E   (hex)		Kunyi electronic technology (Shanghai) Co., Ltd.
200000-2FFFFF     (base 16)		Kunyi electronic technology (Shanghai) Co., Ltd.
				2F, 42th Building, No.1000 Jinhai Road,Pudong
				Shanghai   Shanghai   201206
				CN

2C-27-9E   (hex)		Changzhou WEBO Weighing Device & System CO.,LTD
000000-0FFFFF     (base 16)		Changzhou WEBO Weighing Device & System CO.,LTD
				Gaoyang Road No.1
				Changzhou  Jiangsu  213000
				CN

18-9B-A5   (hex)		Christ Electronic System GmbH
C00000-CFFFFF     (base 16)		Christ Electronic System GmbH
				Alpenstrasse 34
				Memmingen  Bavaria  87700
				DE

2C-27-9E   (hex)		Jiangsu JianHu Science & Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Jiangsu JianHu Science & Technology Co., Ltd.
				No.95 East Guangdian Road of Yaoguan County, Wujin District 
				Changzhou  Jiangsu  213011
				CN

90-4E-91   (hex)		Apollo Video Technology
100000-1FFFFF     (base 16)		Apollo Video Technology
				24000 35th Ave SE
				Bothell  WA  98021
				US

34-29-8F   (hex)		ISRA Vision AG
400000-4FFFFF     (base 16)		ISRA Vision AG
				Industriestraße 14
				Darmstadt    64297
				DE

34-00-8A   (hex)		Hibertek International Limited
A00000-AFFFFF     (base 16)		Hibertek International Limited
				Rm. 6, 21F., NO.5, Sec.3, New Taipei Blvd., Xinzhuang Dist.
				New Taipei City    24250
				TW

34-29-8F   (hex)		Wiesheu GmbH
900000-9FFFFF     (base 16)		Wiesheu GmbH
				Daimlerstr. 10
				Affalterbach    71563
				DE

34-29-8F   (hex)		Highlite International B.V.
500000-5FFFFF     (base 16)		Highlite International B.V.
				Vestastraat 2
				Kerkrade    6468 EX
				NL

28-F5-37   (hex)		Honeywell Safety Products USA, Inc
A00000-AFFFFF     (base 16)		Honeywell Safety Products USA, Inc
				7828 Waterville Road
				San Diego  CA  92154
				US

E8-18-63   (hex)		AVCON Information Technology Co.,Ltd
200000-2FFFFF     (base 16)		AVCON Information Technology Co.,Ltd
				Room 2408, No 2 Building, 335# Guoding Road
				Shanghai  Shanghai  200433
				CN

34-00-8A   (hex)		Shenzhen Andakai Technologies Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen Andakai Technologies Co., Ltd.
				Unit B, 10/F, Building 2, NO.10 Industial Park, Tianliao Community, Gongming Street, GuangMing District, Shenzhen,China
				Shenzhen  Guangdong  518107
				CN

34-00-8A   (hex)		uberGARD Pte. Ltd.
700000-7FFFFF     (base 16)		uberGARD Pte. Ltd.
				39 Sungei Kadut Avenue
				Singapore    729663
				SG

78-D8-00   (hex)		CL International 
E00000-EFFFFF     (base 16)		CL International 
				12th Floor, Woolim Lions Valley 1 Bldg 27, Dunchon-daero 457beongil, Jungwon-gu
				Seongnam   Kyeonggi-do   462-806
				KR

78-D8-00   (hex)		Korea Micro Wireless Co.,Ltd.
D00000-DFFFFF     (base 16)		Korea Micro Wireless Co.,Ltd.
				#323, 3F, Kyoungin Center, 20, Baekbeom-ro 577beon-gil, Bupyeong-gu
				Incheon    21449
				KR

7C-BA-CC   (hex)		Fossil Power Systems Inc
600000-6FFFFF     (base 16)		Fossil Power Systems Inc
				10 Mosher Drive
				Dartmouth  Nova Scotia  B3B1N5
				CA

7C-BA-CC   (hex)		Izkare
300000-3FFFFF     (base 16)		Izkare
				Suite 2812, 800 MinHe Rd
				Hangzhou  Zhejiang  311200
				CN

7C-BA-CC   (hex)		Annapurna labs
A00000-AFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

7C-BA-CC   (hex)		Yongguan Electronic Technology (D.G)LTD
900000-9FFFFF     (base 16)		Yongguan Electronic Technology (D.G)LTD
				xinfeng west 3RD
				Dongguan    523041
				CN

F8-8A-3C   (hex)		Josh.ai
700000-7FFFFF     (base 16)		Josh.ai
				191 University Blvd #188
				Denver  CO  80206
				US

4C-65-A8   (hex)		Fuse
C00000-CFFFFF     (base 16)		Fuse
				1425 E St.
				San Diego    92110
				US

4C-65-A8   (hex)		Beijing Bluehalo Internet Inc.
100000-1FFFFF     (base 16)		Beijing Bluehalo Internet Inc.
				901B,Building A of Power Creative,NO.1 Shangdi East Road,Haidian District,
				Beijing     100085
				CN

4C-65-A8   (hex)		WELT Corporation
000000-0FFFFF     (base 16)		WELT Corporation
				Seocho, Bangbae, 481-5
				Seoul    06699
				KR

A0-C5-F2   (hex)		Serious Integrated, Inc.
A00000-AFFFFF     (base 16)		Serious Integrated, Inc.
				576 East Germann Road
				Gilbert  AZ  85296
				US

A0-C5-F2   (hex)		Oray.com co., LTD.
B00000-BFFFFF     (base 16)		Oray.com co., LTD.
				8008Rm, building No.1 GuoDing d. Yangpu District
				Shanghai  Shanghai  200433
				CN

4C-65-A8   (hex)		Wuhan MoreQuick Network Technology Co., Ltd.
700000-7FFFFF     (base 16)		Wuhan MoreQuick Network Technology Co., Ltd.
				GuangGuDaDao 70#ShiMaoZhongXin C-2205
				WuHan  HuBei  430019
				CN

4C-65-A8   (hex)		SHENZHEN LISAIER TRONICS CO.,LTD
900000-9FFFFF     (base 16)		SHENZHEN LISAIER TRONICS CO.,LTD
				No.22 xihu industrial park ,xikeng henggang Town Longgang District      
				 shenzhen   Guang Dong      518115
				CN

8C-14-7D   (hex)		Shenzhen Meidou Technology Co, Ltd.
600000-6FFFFF     (base 16)		Shenzhen Meidou Technology Co, Ltd.
				Room 321,Building 4,Zhongxinggongyeyuan,  Chuangye Road, Nanshan District
				Shenzhen  Guangdong  518054
				CN

8C-14-7D   (hex)		Unwired Networks
500000-5FFFFF     (base 16)		Unwired Networks
				Gonzagagasse 11/25
				Vienna    1010
				AT

F0-23-B9   (hex)		Domotz Ltd
E00000-EFFFFF     (base 16)		Domotz Ltd
				334 Ladbroke Grove
				London    W10 5AD
				GB

04-71-4B   (hex)		Apparatebau Gauting GmbH
400000-4FFFFF     (base 16)		Apparatebau Gauting GmbH
				Friedrichshafener Strasse 5
				Gilching    82205
				DE

04-71-4B   (hex)		Energport Inc
800000-8FFFFF     (base 16)		Energport Inc
				48660 Kato Road
				Fremont  CA  94538
				US

60-D7-E3   (hex)		HuBDIC CO.,LTD
E00000-EFFFFF     (base 16)		HuBDIC CO.,LTD
				#301, 53, Jeonpa-ro, Manan-gu, Anyang-si
				Gyeonggi-do    14084
				KR

04-71-4B   (hex)		Observables, Inc.
A00000-AFFFFF     (base 16)		Observables, Inc.
				117 N. MILPAS ST
				SANTA BARBARA  CA  93103
				US

F0-23-B9   (hex)		Shenzhen Lachesis Mhealth Co., Ltd.
C00000-CFFFFF     (base 16)		Shenzhen Lachesis Mhealth Co., Ltd.
				Bldg. C, No.43 Yanshan Rd, Nanshan District
				Shenzhen  GuangDong  518067
				CN

60-D7-E3   (hex)		Nextivity
B00000-BFFFFF     (base 16)		Nextivity
				16550 West Bernardo Road, Bldg 5, Suite 550
				San Diego  CA  92127
				US

60-D7-E3   (hex)		Zhejiang Send Intelligent Technology,Ltd
C00000-CFFFFF     (base 16)		Zhejiang Send Intelligent Technology,Ltd
				6-7F,E Building,Tiantang Software Park,Xidoumen Road,Xihu District
				Hangzhou  Zhejiang  310012
				CN

60-D7-E3   (hex)		HindlePower, Inc
800000-8FFFFF     (base 16)		HindlePower, Inc
				1075 Saint John St
				Easton  PA  18042
				US

60-D7-E3   (hex)		Quantronix, Inc.
D00000-DFFFFF     (base 16)		Quantronix, Inc.
				380 S. 200 W.
				Farmington  UT  84025
				US

60-D7-E3   (hex)		Hemisphere GNSS
400000-4FFFFF     (base 16)		Hemisphere GNSS
				8515 E. Anderson Dr.
				Scottsdale  AZ  85255
				US

08-ED-02   (hex)		Savox Communications 
900000-9FFFFF     (base 16)		Savox Communications 
				Laitaatsillantie 3
				Savonlinna    57170
				FI

08-ED-02   (hex)		Szok Energy and Communication Co., Ltd.
B00000-BFFFFF     (base 16)		Szok Energy and Communication Co., Ltd.
				Rm. 1, 17F., No.104, Sec. 1, Xintai 5th Rd., Xizhi Dist.
				New Taipei City    22102
				TW

08-ED-02   (hex)		Guard RFID Solutions
C00000-CFFFFF     (base 16)		Guard RFID Solutions
				#140-766 Cliveden Place
				Delta  BC  V3M6C7
				CA

98-AA-FC   (hex)		RPE RADICO
400000-4FFFFF     (base 16)		RPE RADICO
				Marksa, 14
				Obninsk  Kaluga reg.  249035
				RU

98-AA-FC   (hex)		Nexus Electrical(Jiaxing) Limited
300000-3FFFFF     (base 16)		Nexus Electrical(Jiaxing) Limited
				No 1438,Jiachuang Road,Xiuzhou Industrial Park,
				Jiaxing  Zhejiang  314031
				CN

98-AA-FC   (hex)		Beijing Tiandi-Marco Electro-Hydraulic Control System Company Ltd.
800000-8FFFFF     (base 16)		Beijing Tiandi-Marco Electro-Hydraulic Control System Company Ltd.
				No.5 Qing Nian Gou Road, Hepingli
				Beijing    100013
				CN

98-AA-FC   (hex)		Mekotronics Co., Ltd
600000-6FFFFF     (base 16)		Mekotronics Co., Ltd
				Rm 19C Lockhart Ctr 301-307, Lockhart Rd Wan Chai
				Hong Kong    999077
				HK

98-AA-FC   (hex)		MCS Micronic Computer Systeme GmbH
D00000-DFFFFF     (base 16)		MCS Micronic Computer Systeme GmbH
				Geneststr. 5
				Berlin    10829
				DE

14-4F-D7   (hex)		Arkus-ST Ltd
B00000-BFFFFF     (base 16)		Arkus-ST Ltd
				Generala Antonova 3a
				Moscow    117342
				RU

14-4F-D7   (hex)		i-SENS, Inc.
600000-6FFFFF     (base 16)		i-SENS, Inc.
				43, Banpo-daero 28-gil, Seocho-gu
				Seoul    06646
				KR

1C-A0-D3   (hex)		Cirque Audio Technology Co., Ltd
900000-9FFFFF     (base 16)		Cirque Audio Technology Co., Ltd
				No. 2, Road BeiYiHeng, HuangJiaBao Industrial Park, ShiPai Town,
				DongGuan  GuangDong  523347
				CN

40-F3-85   (hex)		PALAZZETTI LELIO SPA
700000-7FFFFF     (base 16)		PALAZZETTI LELIO SPA
				VIA ROVEREDO 103
				PORCIA  PORDENONE  33080
				IT

A4-11-63   (hex)		accesso Technology Group
900000-9FFFFF     (base 16)		accesso Technology Group
				Unit 5, The Pavillions, Ruscombe Business Park
				Twyford  Wilts  RG10 9NN
				GB

1C-A0-D3   (hex)		Guang Dong He Zheng Network Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Guang Dong He Zheng Network Technology Co.,Ltd
				N0.3,Sanjiang industrial zone,Hengli Town
				Dongguan  Guangdong  523460
				CN

8C-C8-F4   (hex)		SHENZHEN D-light Technolgy Limited
600000-6FFFFF     (base 16)		SHENZHEN D-light Technolgy Limited
				2302F, Block B, Wisdom Building ,Qiao xiang Road,Shahe Street, Nanshan District,
				Shenzhen  Guangdong  518000
				CN

8C-C8-F4   (hex)		Trilux Group Management GmbH
A00000-AFFFFF     (base 16)		Trilux Group Management GmbH
				Heidestrasse
				Arnsberg    59759
				DE

40-F3-85   (hex)		IntelliDesign Pty Ltd
300000-3FFFFF     (base 16)		IntelliDesign Pty Ltd
				99 Bluestone Circuit
				Seventeen Mile Rocks  Qld  4073
				AU

40-F3-85   (hex)		Embedded IQ
400000-4FFFFF     (base 16)		Embedded IQ
				Block C, HHK House; 22 Ethel Avenue
				Johannesburg  Gauteng  2195
				ZA

8C-C8-F4   (hex)		TOHO DENKI IND.CO.,LTD
300000-3FFFFF     (base 16)		TOHO DENKI IND.CO.,LTD
				1-6-30 Meguro
				Meguro-ku  Tokyo  153-0063
				JP

50-A4-D0   (hex)		XinLian'AnBao（Beijing）Technology Co.，LTD.
800000-8FFFFF     (base 16)		XinLian'AnBao（Beijing）Technology Co.，LTD.
				（Room 501,Building 10, Area 2, Headquarters Base）NO.188,South 4th Ring West Road, Fengtai District
				Beijing  Beijing  100070
				CN

8C-C8-F4   (hex)		Lanhomex Technology(Shen Zhen)Co.,Ltd. 
100000-1FFFFF     (base 16)		Lanhomex Technology(Shen Zhen)Co.,Ltd. 
				Room 409, Building 29,Zhi Heng Industrial Part, Guankou 2nd  Road, Nanshan District
				SHENZHEN    518000
				CN

8C-C8-F4   (hex)		Swift Navigation Inc
900000-9FFFFF     (base 16)		Swift Navigation Inc
				1543 Mission Street
				San Francisco  CA  94103
				US

50-A4-D0   (hex)		Shanghai Pujiang Smart Card Systems Co., Ltd.
700000-7FFFFF     (base 16)		Shanghai Pujiang Smart Card Systems Co., Ltd.
				No.100, Lane 7488, Hutai Road
				Shanghai    86-201809
				CN

8C-C8-F4   (hex)		Guardtec,Inc
000000-0FFFFF     (base 16)		Guardtec,Inc
				Hanshin IT tower #1203 Digital-ro 272 GUROGU
				SEOUL    08389
				KR

50-A4-D0   (hex)		OEM PRODUCTION INC.
900000-9FFFFF     (base 16)		OEM PRODUCTION INC.
				1461-3 San Mateo Ave.
				South San Francisco  CA  94080
				US

34-04-9E   (hex)		Eginity, Inc.
B00000-BFFFFF     (base 16)		Eginity, Inc.
				37 N Orange Ave STE 770
				Orlando    32801
				US

34-04-9E   (hex)		Eclipse Information Technologies
800000-8FFFFF     (base 16)		Eclipse Information Technologies
				Gulsuyu Mah. Fevzi Cakmak Cad Lefke Sk 16/6
				Istanbul  Turkey  34848
				TR

50-A4-D0   (hex)		TREXOM S.r.l.
500000-5FFFFF     (base 16)		TREXOM S.r.l.
				viale dell'Unione Europea, 19
				TARCENTO  Udine  33017
				IT

40-ED-98   (hex)		Siebert Industrieelektronik GmbH
B00000-BFFFFF     (base 16)		Siebert Industrieelektronik GmbH
				Siebertstrasse 2
				Eppelborn    66571
				DE

40-ED-98   (hex)		Vaisala Oyj
700000-7FFFFF     (base 16)		Vaisala Oyj
				Vanha Nurmijarventie 21
				VANTAA    Fin-01670
				FI

34-04-9E   (hex)		uikismart
D00000-DFFFFF     (base 16)		uikismart
				Nanshan
				Shenzhen  Guangdong  518061
				CN

40-ED-98   (hex)		Shanghai Broadwan Communications Co.,Ltd
600000-6FFFFF     (base 16)		Shanghai Broadwan Communications Co.,Ltd
				Building G, No.1015, Caobao Rd
				Shanghai  Shanghai  200233
				CN

40-ED-98   (hex)		Cape
500000-5FFFFF     (base 16)		Cape
				1040 Mariposa St
				San Francisco  CA  94107
				US

40-ED-98   (hex)		Tsinghua Tongfang Co., LTD
000000-0FFFFF     (base 16)		Tsinghua Tongfang Co., LTD
				Wangzhuang Road No.1, Haidian District, Beijing, Tsinghua Tongfang Technology Plaza. D 21st Floor
				Beijing  Beijing  100083
				CN

A4-58-0F   (hex)		EYE IO, LLC
D00000-DFFFFF     (base 16)		EYE IO, LLC
				2000 University Ave. Suite 610
				Palo Alto  CA  94303
				US

A4-58-0F   (hex)		Astro, Inc
600000-6FFFFF     (base 16)		Astro, Inc
				450 W. 33rd St
				New York  NY  10001
				US

A4-58-0F   (hex)		GUANGZHOU OPTICAL BRIDGE COMMUNICATION EQUIPMENT CO.,LTD.
A00000-AFFFFF     (base 16)		GUANGZHOU OPTICAL BRIDGE COMMUNICATION EQUIPMENT CO.,LTD.
				room b201,NO.263,middle of zhougshan avenue,tianhe
				guangzhou    510660
				CN

50-0B-91   (hex)		Panasonic Enterprise Solutions Company
800000-8FFFFF     (base 16)		Panasonic Enterprise Solutions Company
				6144 N Panasonic Way
				Denver  CO  80249
				US

24-4E-7B   (hex)		Leshi Internet Information & Technology (Beijing) Corp.
400000-4FFFFF     (base 16)		Leshi Internet Information & Technology (Beijing) Corp.
				Fl 16, Letv Building, 105 Yaojiayuan Road, Chaoyang District, Beijing,China
				Beijing    100025
				CN

24-4E-7B   (hex)		WithWin Technology ShenZhen CO.,LTD
E00000-EFFFFF     (base 16)		WithWin Technology ShenZhen CO.,LTD
				29F, East Tower, NanShan Digital Technology & Cultural Industry Park, ShenNan Throughfare10128#
				ShenZhen  China  518000
				CN

24-4E-7B   (hex)		Jiangsu Xuanbo Electronic Technologies Co.,Ltd
500000-5FFFFF     (base 16)		Jiangsu Xuanbo Electronic Technologies Co.,Ltd
				Nearby the Bus stop of Hanzi Industrial Park,Danjin Road,Hengtang Town
				Danyang  Jiangsu  212300
				CN

50-0B-91   (hex)		Shenzhen Xinfa Electronic Co.,ltd
700000-7FFFFF     (base 16)		Shenzhen Xinfa Electronic Co.,ltd
				No 57, Baoli Road, Buji Town
				Longgang District  Shenzhen, Guangdong   518112
				CN

7C-CB-E2   (hex)		mirakonta s.l.
C00000-CFFFFF     (base 16)		mirakonta s.l.
				calle zuatzu nº1 (edif ulia) pabellon 7 (parque emp. zuatzu)
				san sebastian  guipuzcoa  20018
				ES

7C-CB-E2   (hex)		Polarteknik Oy
800000-8FFFFF     (base 16)		Polarteknik Oy
				Klaavolantie 1
				Huittinen    32700
				FI

24-4E-7B   (hex)		RCC TIME CO .,LIMITED
200000-2FFFFF     (base 16)		RCC TIME CO .,LIMITED
				6/F,C2Block,Guang Hao Feng Industrial Park,Hang Cheng Road,Gushu
				Hong Kong    518000
				HK

48-65-EE   (hex)		Mission Microwave Technologies, Inc
400000-4FFFFF     (base 16)		Mission Microwave Technologies, Inc
				10012 Norwalk Blvd, Suite 150
				Santa Fe Springs  CA  90670
				US

48-65-EE   (hex)		Venture Research Inc.
700000-7FFFFF     (base 16)		Venture Research Inc.
				3001 Summit Ave
				Plano  TX  75074
				US

1C-C0-E1   (hex)		LX Corporation Pty Ltd
800000-8FFFFF     (base 16)		LX Corporation Pty Ltd
				Suite 101, Level 1, National Innovation Centre Building, 4 Cornwallis Street
				Eveleigh  New South Wales  2015
				AU

4C-E1-73   (hex)		outpaceIO
300000-3FFFFF     (base 16)		outpaceIO
				44 rue Armand Carrel
				Montreuil    93100
				FR

4C-E1-73   (hex)		Plus One Japan Limited
E00000-EFFFFF     (base 16)		Plus One Japan Limited
				2-8-6,Nishishinbashi
				Minato-ku  Tokyo  105-0003
				JP

1C-C0-E1   (hex)		Shenzhen Highsharp Electronics Ltd.
000000-0FFFFF     (base 16)		Shenzhen Highsharp Electronics Ltd.
				A8 Music Tower 2007-08, High-tech Park
				Shenzhen  Guangdong  518000
				CN

4C-E1-73   (hex)		REMONDE NETWORK 
C00000-CFFFFF     (base 16)		REMONDE NETWORK 
				Room 504 Building A, 3 Juquan Road, Science Town
				Guangzhou  Guangdong  510170
				CN

0C-EF-AF   (hex)		Kenmore
000000-0FFFFF     (base 16)		Kenmore
				3333 Beverly Rd.
				Hoffman Estates  IL  60179
				US

38-3A-21   (hex)		Shenzhen HS Fiber Communication Equipment CO., LTD
200000-2FFFFF     (base 16)		Shenzhen HS Fiber Communication Equipment CO., LTD
				6F, Bld#A, Dezhong Industrial Park, Yangmei Village, Bantian Town, Longgang District
				Shenzhen  Guangdong  518129
				CN

AC-64-DD   (hex)		8Cups
400000-4FFFFF     (base 16)		8Cups
				29, Gonghang-daero 61-gil, Gangseo-gu
				Seoul    07563
				KR

AC-64-DD   (hex)		JSC InfoTeCS
100000-1FFFFF     (base 16)		JSC InfoTeCS
				Staryy Petrovsko-Razumovsky proyezd, 1/23, bld.1
				Moscow    127287
				RU

AC-64-DD   (hex)		Groupe Citypassenger Inc
B00000-BFFFFF     (base 16)		Groupe Citypassenger Inc
				1117 sainte catherine ouest
				Montreal  Quebec  H3B1H9
				CA

38-3A-21   (hex)		Colooc AB
D00000-DFFFFF     (base 16)		Colooc AB
				Nåsvägen 9
				Bromma  Sverige  16775
				SE

38-3A-21   (hex)		Shenzhen Smart-core Technology co., Ltd.
600000-6FFFFF     (base 16)		Shenzhen Smart-core Technology co., Ltd.
				16/F., Finance & Technology Building, No. 11 Keyuan Road, Nanshan Dist.
				Shenzhen  Guangdong  518057
				CN

F8-1D-78   (hex)		Digital Imaging Technology
400000-4FFFFF     (base 16)		Digital Imaging Technology
				2275 Research Blvd Suite 500
				Rockville  MD  20850
				US

F8-1D-78   (hex)		SHANGHAI SUN TELECOMMUNICATION CO., LTD.
300000-3FFFFF     (base 16)		SHANGHAI SUN TELECOMMUNICATION CO., LTD.
				Building No.145, Lane 666 Xianing Road, Jinshan Industrial Zone
				Shanghai  Shanghai  201506
				CN

F8-1D-78   (hex)		Tofino
D00000-DFFFFF     (base 16)		Tofino
				255 Fourier Avenue
				Fremont    94539
				US

F8-1D-78   (hex)		AVPro Global Holdings LLC
A00000-AFFFFF     (base 16)		AVPro Global Holdings LLC
				3518 N Casco Ave
				Sioux Falls  SD  57104
				US

38-3A-21   (hex)		Dongguan Innovation Technology Co Ltd
400000-4FFFFF     (base 16)		Dongguan Innovation Technology Co Ltd
				Building B, No.3 Desheng Road, Longbeiling, Tangxia 
				Dongguan City  Guangdong Province  523715
				CN

70-F8-E7   (hex)		Fixstars Corporation
C00000-CFFFFF     (base 16)		Fixstars Corporation
				1-11-1 Ohsaki
				Shinagawa-ku  TOKYO  141-0032
				JP

70-F8-E7   (hex)		VOXX International
200000-2FFFFF     (base 16)		VOXX International
				180 Marcus Blvd.
				Hauppauge  NY  11788
				US

84-E0-F4   (hex)		Scale-Tec Ltd.
E00000-EFFFFF     (base 16)		Scale-Tec Ltd.
				16027 Hwy 64
				Anamosa  IA  52205
				US

84-E0-F4   (hex)		Hangzhou Uni-Ubi Co.,Ltd.
200000-2FFFFF     (base 16)		Hangzhou Uni-Ubi Co.,Ltd.
				Room 605, Building No.5, HaiChuang Park, No.998, Wenyi Road(West), YuHang District
				HangZhou  ZheJiang  311121
				CN

C0-D3-91   (hex)		xxter bv
900000-9FFFFF     (base 16)		xxter bv
				Elandsgracht 73
				Amsterdam    1016 TR
				NL

58-E8-76   (hex)		Xiamen Cacamle Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Xiamen Cacamle Technology Co.,Ltd.
				Room 1501,15th floor,Building C,DaTang YOHO Park,Huli district
				Xiamen  Fujian  361000
				CN

58-E8-76   (hex)		Broad Air Technology Co., LTD.
500000-5FFFFF     (base 16)		Broad Air Technology Co., LTD.
				Broadtown
				Changsha  Hunan  410126
				CN

C0-D3-91   (hex)		ALNETz Co.,LTD
700000-7FFFFF     (base 16)		ALNETz Co.,LTD
				1-3 Honcho,Naka-ku
				Yokohama  Kanagawa  231-0005
				JP

58-E8-76   (hex)		Annapurna labs
B00000-BFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

58-E8-76   (hex)		McWong International Inc
300000-3FFFFF     (base 16)		McWong International Inc
				1921 Arena Blvd
				Sacramento  CA  95834
				US

F0-AC-D7   (hex)		Intenta GmbH
100000-1FFFFF     (base 16)		Intenta GmbH
				Annabergerstraße 240
				Chemnitz  Sachsen  09125
				DE

F0-AC-D7   (hex)		QUANTUM POWER SYSTEMS
200000-2FFFFF     (base 16)		QUANTUM POWER SYSTEMS
				B11. 3RD CROSS. ITI IND. ESTATE. MAHADEVAPURA
				BANGALORE  KARNATAKA  560048
				IN

F0-AC-D7   (hex)		Med-Pat/Inn-Phone
300000-3FFFFF     (base 16)		Med-Pat/Inn-Phone
				31 Riordan Place
				Shrewsbury  NJ  07702
				US

F0-AC-D7   (hex)		 Guilin glsun Science and Tech Co.,LTD
000000-0FFFFF     (base 16)		 Guilin glsun Science and Tech Co.,LTD
				Block D-08, National IT Industry Park, Chaoyang Rd
				Guilin  Guangxi  541000
				CN

28-36-38   (hex)		SCA Hygiene Products AB
E00000-EFFFFF     (base 16)		SCA Hygiene Products AB
				Mölndals bro 2
				405 03 Göteborg    -
				SE

28-36-38   (hex)		ShangHai Canall Information Technology Co.,Ltd
B00000-BFFFFF     (base 16)		ShangHai Canall Information Technology Co.,Ltd
				11F,TongLian Building,1565 Jiaotong Rd.,ShangHai 200065,P.R.C.
				ShangHai  ShangHai  200065
				CN

28-36-38   (hex)		Havells India Limited
800000-8FFFFF     (base 16)		Havells India Limited
				Head Office, Havells India Ltd QRG Towers, 2D, Sector 126
				Noida  UP  201304
				IN

28-36-38   (hex)		Innovative Technology Ltd
700000-7FFFFF     (base 16)		Innovative Technology Ltd
				Innovative Business Park, Derker Street
				Oldham    OL1 4EQ
				GB

8C-19-2D   (hex)		TeleAlarm SA
A00000-AFFFFF     (base 16)		TeleAlarm SA
				Rue du Pont 23
				 La Chaux-de-Fonds    2300
				CH

38-B8-EB   (hex)		ExaScaler Inc.
B00000-BFFFFF     (base 16)		ExaScaler Inc.
				Kimura Bldg. 5F, Kanda Ogawamachi 2-1
				Chiyoda-ku  Tokyo  101-0052
				JP

8C-19-2D   (hex)		Shenzhen Huanuo Internet Technology Co.,Ltd
100000-1FFFFF     (base 16)		Shenzhen Huanuo Internet Technology Co.,Ltd
				Room 10G, Tower 4C, Software Industry Base, Nanshan District, ShenZhen, China, 518000.
				Shenzhen    518000
				CN

D0-D9-4F   (hex)		Perfant Technology Co., Ltd
000000-0FFFFF     (base 16)		Perfant Technology Co., Ltd
				Guo Ren Tong Xin B317,Ke Ji Zhong San Lu,Nanshan,Shenzhen,Guangdong,China
				Shenzhen    518000
				CN

D0-D9-4F   (hex)		Apption Labs Limited
800000-8FFFFF     (base 16)		Apption Labs Limited
				7-8 Westbridge Close
				Leicester    LE3 5LW
				GB

D0-D9-4F   (hex)		Optigo Networks
500000-5FFFFF     (base 16)		Optigo Networks
				#320 – 887 Great Northern Way
				Vancouver  BC  V5T 4T5
				CA

D0-D9-4F   (hex)		Beijing Yiwangxuntong Technology
300000-3FFFFF     (base 16)		Beijing Yiwangxuntong Technology
				Room 1605, Unit 2, Building No.1, ShangAoShiJi Center, XiSanQi
				Beijing  Select State  100096
				CN

D0-D9-4F   (hex)		peiker CEE
400000-4FFFFF     (base 16)		peiker CEE
				Gartenstrasse 25
				Bad Homburg    61352
				DE

CC-D3-1E   (hex)		Haishu Technology LIMITED
A00000-AFFFFF     (base 16)		Haishu Technology LIMITED
				Jiulong Midun street No.89
				Hongkong    999077
				HK

C4-7C-8D   (hex)		HHCC Plant Technology Co.,Ltd.
600000-6FFFFF     (base 16)		HHCC Plant Technology Co.,Ltd.
				Floor 12,A build ,Shuguang Plaza, Jingshun road, Chaoyang district
				Beijing  Beijing  100028
				CN

CC-D3-1E   (hex)		Elk Products
B00000-BFFFFF     (base 16)		Elk Products
				3266 Highway 70 West
				Hildebran  NC  28637
				US

CC-D3-1E   (hex)		BBPOS International Limited
600000-6FFFFF     (base 16)		BBPOS International Limited
				Suite 1602, Tower 2, Nina Tower, 8 Yeung Uk Road, Tsuen Wan, NT
				Hong Kong  China  00000
				HK

68-91-D0   (hex)		Altis Technology 
B00000-BFFFFF     (base 16)		Altis Technology 
				711 Lu Plaza, 2 Wing Yip Street, Kwun Tong
				Hong Kong    0000
				HK

C4-7C-8D   (hex)		Awiselink Co., Ltd.
700000-7FFFFF     (base 16)		Awiselink Co., Ltd.
				7F., No.98, Minquan Rd., Xindian Dist.
				New Taipei City     23141
				TW

C4-7C-8D   (hex)		INOTEC Sicherheitstechnik GmbH
C00000-CFFFFF     (base 16)		INOTEC Sicherheitstechnik GmbH
				Am Buschgarten 17
				Ense  NRW  59469
				DE

68-91-D0   (hex)		WiseCube
A00000-AFFFFF     (base 16)		WiseCube
				14F IT Castle-2, 137 Gasan Digital 1-ro, Geumcheon-gu
				Seoul    08506
				KR

C4-7C-8D   (hex)		Airbus DS - SLC
900000-9FFFFF     (base 16)		Airbus DS - SLC
				1, Bd Jean Moulin - Metapole
				ELANCOURT   Cedex    78996
				FR

C4-7C-8D   (hex)		PASCAL Co., Ltd.
500000-5FFFFF     (base 16)		PASCAL Co., Ltd.
				1-8-31, Honjo-Nishi
				Higashiosaka  Osaka-hu  5780965
				JP

68-91-D0   (hex)		Omniimpex GmbH
700000-7FFFFF     (base 16)		Omniimpex GmbH
				Waldhof 5
				Zug  Zug  6300
				CH

E0-B6-F5   (hex)		Agora
400000-4FFFFF     (base 16)		Agora
				16, rue Alfred Nobel
				POITIERS  Poitou-Charentes  86000
				FR

E0-B6-F5   (hex)		Folksam AB
A00000-AFFFFF     (base 16)		Folksam AB
				Bohusgatan 14
				Stockholm    10660
				SE

E0-B6-F5   (hex)		ITEL MOBILE LIMITED
D00000-DFFFFF     (base 16)		ITEL MOBILE LIMITED
				RM B3 & B4 BLOCK B, KO FAI INDUSTRIAL BUILDING  NO.7 KO FAI ROAD, YAU TONG, KLN, H.K
				Hong Kong  KOWLOON  999077
				HK

50-FF-99   (hex)		Goetting KG
C00000-CFFFFF     (base 16)		Goetting KG
				Celler Str. 5
				Lehrte  Select Your State or Province  31275
				DE

50-FF-99   (hex)		Shenzhen Haipengxin Electronic Co., Ltd.
D00000-DFFFFF     (base 16)		Shenzhen Haipengxin Electronic Co., Ltd.
				Block C3,Mingzhuo Xingye Technology Park,Guangming Avenue
				Shenzhen  Guangdong  518107
				CN

50-FF-99   (hex)		Sichuan Dowlab Electronics Technology Co. Ltd
B00000-BFFFFF     (base 16)		Sichuan Dowlab Electronics Technology Co. Ltd
				NO.198, Wenjia Street, Qingyang District
				Chengdu  Sichuan  610091
				CN

98-6D-35   (hex)		Shenzhen cositea electronics technology co.,LTD
100000-1FFFFF     (base 16)		Shenzhen cositea electronics technology co.,LTD
				 Nanshan District  Xili academy Avenue Tong Long Industrial A District 7 Building 3 floor
				shenzhen  guandong  518000
				CN

7C-47-7C   (hex)		EyeLock LLC
300000-3FFFFF     (base 16)		EyeLock LLC
				355 Lexington Ave., 12th Floor
				New York  NY  10017
				US

98-6D-35   (hex)		Beijing 3CAVI Tech Co.,Ltd
800000-8FFFFF     (base 16)		Beijing 3CAVI Tech Co.,Ltd
				Unit 203,Block D Keshi Building, Shangdi Xinxi Road, Haidian District
				Beijing    100085
				CN

7C-47-7C   (hex)		Annapurna labs
C00000-CFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

5C-F2-86   (hex)		VPInstruments
600000-6FFFFF     (base 16)		VPInstruments
				Buitenwatersloot 335
				Delft    2614GS
				NL

5C-F2-86   (hex)		Shanghai Notion Information Technology CO.,LTD.
200000-2FFFFF     (base 16)		Shanghai Notion Information Technology CO.,LTD.
				Room 201,Building 3,NO 289,Bisheng Rd,Pudong district,Shanghai,China
				Shanghai  Shanghai  201203
				CN

5C-F2-86   (hex)		Sunpet Industries Limited
C00000-CFFFFF     (base 16)		Sunpet Industries Limited
				Unit 618, Lakeside 2, Hong Kong Science Park
				Shatin  N.T.  -
				HK

5C-F2-86   (hex)		beijing your wonderful control system technology co.,ltd
300000-3FFFFF     (base 16)		beijing your wonderful control system technology co.,ltd
				NO.11 Fengxian Medium Road,Yongfeng Industry Base,Haidian District,Beijing
				beijing  beijing  100094
				CN

5C-F2-86   (hex)		EUROIMMUN Medizinische Labordiagnostika AG
500000-5FFFFF     (base 16)		EUROIMMUN Medizinische Labordiagnostika AG
				Seekamp 31
				Lübeck  Schleswig-Holstein  23560
				DE

5C-F2-86   (hex)		BrightSky, LLC
D00000-DFFFFF     (base 16)		BrightSky, LLC
				5121 Castello Drive
				Naples  null  34103-1927
				US

38-FD-FE   (hex)		iSmart electronic technology co.,LTD
E00000-EFFFFF     (base 16)		iSmart electronic technology co.,LTD
				Room2101,DeWei Building,4 YunShan West Road,JiangBei,
				HuiZhou  GuangDong  516000
				CN

5C-F2-86   (hex)		SHENZHEN HIVT TECHNOLOGY CO.,LTD
800000-8FFFFF     (base 16)		SHENZHEN HIVT TECHNOLOGY CO.,LTD
				7 F,3rd Zone,B Block,Mingyou purchasing Center,Baoyuan RD,Xixiang,Bao'an District,Shenzhen,China
				Shenzhen  Guangdong  518100
				CN

38-FD-FE   (hex)		Rademacher Geraete-Elektronik GmbH
700000-7FFFFF     (base 16)		Rademacher Geraete-Elektronik GmbH
				Buschkamp 7
				Rhede  NRW  46414
				DE

38-FD-FE   (hex)		Smart Solution Technology, Inc
200000-2FFFFF     (base 16)		Smart Solution Technology, Inc
				1-15 Kagurazaka,Shinjyukuku,
				Tokyo    162-0825
				JP

38-B8-EB   (hex)		Wyres SAS
E00000-EFFFFF     (base 16)		Wyres SAS
				24 rue henri barbusse
				Echirolles  Isere  38130
				FR

78-CA-83   (hex)		Excelocity Inc.
100000-1FFFFF     (base 16)		Excelocity Inc.
				200 Colonnade Road Suite #8
				Ottawa  Ontario  K2E 7M1
				CA

78-CA-83   (hex)		Louroe Electronics
900000-9FFFFF     (base 16)		Louroe Electronics
				6955 Valjean Avenue
				Van Nuys  CA  91406
				US

38-B8-EB   (hex)		Dojo-Labs Ltd
500000-5FFFFF     (base 16)		Dojo-Labs Ltd
				Hatidhar 17
				Raanana    346651
				IL

78-CA-83   (hex)		DAINCUBE
000000-0FFFFF     (base 16)		DAINCUBE
				#401-701, 655, Pyeongcheon-ro
				Bucheon-si    14502
				KR

1C-88-79   (hex)		Airsmart System Co.,Ltd
200000-2FFFFF     (base 16)		Airsmart System Co.,Ltd
				 Unit416 , Tudao Intelligent Technology Building, No.9 KeJi Road ,Science and Technology Park, Nanshan District , 
				Shenzhen  Guangdong  518000
				CN

1C-88-79   (hex)		Eolos IT Corp
600000-6FFFFF     (base 16)		Eolos IT Corp
				 3663 SW 8 th Street, STE 210 
				Miami  FL  33135
				US

1C-88-79   (hex)		Accriva
C00000-CFFFFF     (base 16)		Accriva
				6260 Sequence Dr
				San Diego  CA  92121
				US

1C-87-79   (hex)		BEIDIAN  GROUP
500000-5FFFFF     (base 16)		BEIDIAN  GROUP
				A2 501 Jingang Road Pudong Jinqiao Shanghai
				Shanghai  Shanghai  200126
				CN

1C-87-79   (hex)		Shenzhen Innovaconn Systems Co.,Ltd
D00000-DFFFFF     (base 16)		Shenzhen Innovaconn Systems Co.,Ltd
				1F East of Building D,Science and Technology Park,NO.2 Kefeng Road,
				Shenzhen  Guangdong  518000
				CN

1C-87-79   (hex)		AllThingsTalk
C00000-CFFFFF     (base 16)		AllThingsTalk
				Ajuinlei 1
				Gent    9000
				BE

1C-87-76   (hex)		EBS Sp. z o.o.
100000-1FFFFF     (base 16)		EBS Sp. z o.o.
				ul. Bronisława Czecha 59
				Warszawa  Mazowieckie  04-555
				PL

1C-87-79   (hex)		Shenzhen Shouxin Tongda Technology Co.,Ltd
600000-6FFFFF     (base 16)		Shenzhen Shouxin Tongda Technology Co.,Ltd
				Rm.1301-1305A,Fujian Building, Caitian road, Futian District,
				Shenzhen  Guangdong  China
				CN

84-39-BE   (hex)		Shenzhen Lidaxun Digital Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Shenzhen Lidaxun Digital Technology Co.,Ltd
				4th Floor 3B03-3B05, Building 2,Internet Industries Park Area A, Baoan district
				Shenzhen  Guangdong  51800
				CN

84-39-BE   (hex)		EDC Electronic Design Chemnitz GmbH
C00000-CFFFFF     (base 16)		EDC Electronic Design Chemnitz GmbH
				Technologie-Campus 4
				Chemnitz  Sachsen  09126
				DE

84-39-BE   (hex)		Emotiq s.r.l.
A00000-AFFFFF     (base 16)		Emotiq s.r.l.
				Via Cristoforo Baioni 9
				Bergamo  BG  24123
				IT

40-A3-6B   (hex)		PH Technical Labs
900000-9FFFFF     (base 16)		PH Technical Labs
				1200, commerce dr, ste 112
				plano  tx  75093
				US

80-0A-80   (hex)		Beijing VControl Technology Co., Ltd.
300000-3FFFFF     (base 16)		Beijing VControl Technology Co., Ltd.
				Qinghe Anning Road, Wuyougang building #22
				Beijing  Haidian  100085
				CN

80-0A-80   (hex)		Sumitomo Wiring Systems, Ltd.
200000-2FFFFF     (base 16)		Sumitomo Wiring Systems, Ltd.
				Nagoya Lucent Tower 25F
				Nagoya  Aichi  451-6025
				JP

80-0A-80   (hex)		LLVISION TECHNOLOGY CO.,LTD
400000-4FFFFF     (base 16)		LLVISION TECHNOLOGY CO.,LTD
				Room302,Building A Fuxing,No.30 He Tao Yuan,Guan Dong Dian Bei Jie
				Beijing  Beijing  100026
				CN

CC-1B-E0   (hex)		IC RealTech
600000-6FFFFF     (base 16)		IC RealTech
				3050 North Andrews Avenue Extension
				Pompano Beach  Florida  33064
				US

00-55-DA   (hex)		Beijing Connected Information Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Beijing Connected Information Technology Co.,Ltd.
				F15 Block 7(Jing Xi Financial Science and Technology Building)No.30 Shi Xing St,Shijingshan District Beijing, China,100041
				Beijing  Beijing  100041
				CN

CC-1B-E0   (hex)		MobiStor Technology Inc.
900000-9FFFFF     (base 16)		MobiStor Technology Inc.
				Rm. 209, 2F., No. 99-1, Anzhong Rd., Xindian Dist.
				New Taipei City  Taiwn  23154
				TW

CC-1B-E0   (hex)		MDT technologies GmbH
800000-8FFFFF     (base 16)		MDT technologies GmbH
				Papiermühle 1
				Engelskirchen  Engelskirchen  51766
				DE

CC-1B-E0   (hex)		NEWSTAR (HK) ELECTRONIC DEVELOPMENT LIMITED
D00000-DFFFFF     (base 16)		NEWSTAR (HK) ELECTRONIC DEVELOPMENT LIMITED
				UNIT 1005,10/F PROSPEROUS BLDG 48-52 DES VOEUX ROAD GENTRAL HONG KONG
				HONGKONG  HONGKONG  999077
				CN

00-55-DA   (hex)		Interaxon Inc
B00000-BFFFFF     (base 16)		Interaxon Inc
				Suite 303 - 511 King St W
				Toronto  ON  M5V 1K4
				CA

00-55-DA   (hex)		Arrow Electronics,Inc.
D00000-DFFFFF     (base 16)		Arrow Electronics,Inc.
				665 Maestro Drive
				Reno  NV  89511
				US

CC-1B-E0   (hex)		Shenzhen Vanstor Technology Co.,Ltd
300000-3FFFFF     (base 16)		Shenzhen Vanstor Technology Co.,Ltd
				nanshan District
				shenzhen  GuangDong  518057
				CN

A0-3E-6B   (hex)		Qunar.com
C00000-CFFFFF     (base 16)		Qunar.com
				xihaiguoji,1#8
				Beijing  Beijing  100086
				CN

A0-3E-6B   (hex)		718th  Research  Institute  of  CSIC
800000-8FFFFF     (base 16)		718th  Research  Institute  of  CSIC
				No.17 Zhanlan Road
				Handan City  Hebei  056027
				CN

A0-3E-6B   (hex)		Incogniteam Ltd.
900000-9FFFFF     (base 16)		Incogniteam Ltd.
				ROTERMANI 8
				Tallin  Estonia  10111
				EE

A0-3E-6B   (hex)		Friday Lab, UAB
500000-5FFFFF     (base 16)		Friday Lab, UAB
				Sauletekio ave 15
				Vilnius  Vilnius  10224
				LT

C8-8E-D1   (hex)		AP Sensing GmbH
A00000-AFFFFF     (base 16)		AP Sensing GmbH
				Herrenberger Str. 130
				Böblingen  Baden-Würrtemberg  71034
				DE

C8-8E-D1   (hex)		Shenyang Machine Tool(Group) Research & Design Institute Co., Ltd, Shanghai Branch
600000-6FFFFF     (base 16)		Shenyang Machine Tool(Group) Research & Design Institute Co., Ltd, Shanghai Branch
				2nd Floor,1st Building, No. 128 Xiangyin Rd, Shanghai
				Shanghai  Shanghai  200433
				CN

C8-8E-D1   (hex)		ROTRONIC AG
200000-2FFFFF     (base 16)		ROTRONIC AG
				Grindelstrasse 6
				Bassersdorf  Zurich  8303
				CH

A0-3E-6B   (hex)		Videx Electronics S.p.A.
200000-2FFFFF     (base 16)		Videx Electronics S.p.A.
				Via del Lavoro, 1
				Monte Giberto  FM  63846
				IT

DC-44-27   (hex)		Wharton Electronics Ltd
800000-8FFFFF     (base 16)		Wharton Electronics Ltd
				Unit 15, Thame Park Business Centre
				Thame  Oxfordshire  OX9 3XA
				GB

1C-21-D1   (hex)		Dynojet Research
900000-9FFFFF     (base 16)		Dynojet Research
				2191 Mendenhall #105
				North Las Vegas  NV  89081
				US

1C-21-D1   (hex)		Reliatronics Inc.
800000-8FFFFF     (base 16)		Reliatronics Inc.
				1858 Ranch Road 3232
				Johnson City  TX  78636
				US

B0-C5-CA   (hex)		Astyx GmbH
800000-8FFFFF     (base 16)		Astyx GmbH
				Lise-Meitner-Str. 2a
				Ottobrunn  Bavaria  85521
				DE

DC-44-27   (hex)		General Microsystems Sdn Bhd
300000-3FFFFF     (base 16)		General Microsystems Sdn Bhd
				3-17, Jalan USJ 7/3B
				UEP Subang Jaya  Selangor D. E.  47610
				MY

DC-44-27   (hex)		Suritel
000000-0FFFFF     (base 16)		Suritel
				5, ul. Usievicha
				Moscow  Moscow  125319
				RU

1C-21-D1   (hex)		B-Scada Inc.
500000-5FFFFF     (base 16)		B-Scada Inc.
				9030 W Fort Island Trail
				Crystal River  FL  34429
				US

B0-C5-CA   (hex)		IVK-SAYANY
100000-1FFFFF     (base 16)		IVK-SAYANY
				Aviamotornaya str. 50
				Moscow  Moscow  111024
				RU

B0-C5-CA   (hex)		SYSTOVI
500000-5FFFFF     (base 16)		SYSTOVI
				5, rue du Chêne Lassé
				SAINT-HERBLAIN  Loire-Atlantique  44800
				FR

78-C2-C0   (hex)		Wan Chao An (Beijing) Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Wan Chao An (Beijing) Technology Co., Ltd.
				Room 1-1-1403, Shang Di Jia Yuan
				Beijing  Beijing  100085
				CN

B4-37-D1   (hex)		DIMTON CO.,LTD.
300000-3FFFFF     (base 16)		DIMTON CO.,LTD.
				1F.,No.137,Xingfu E.Rd., Xinzhuang Dist., New Taipei City 242, Taiwan (R.O.C)
				New Taipei  Taiwan  24252
				TW

B4-37-D1   (hex)		Alturna Networks
100000-1FFFFF     (base 16)		Alturna Networks
				De Huchtstraat 35
				Almere  Flevoland  1327 EC
				NL

B4-37-D1   (hex)		Fibersystem AB
200000-2FFFFF     (base 16)		Fibersystem AB
				Gårdsfogdevägen 18B
				Bormma  Stockholm  16866
				SE

78-C2-C0   (hex)		Shenzhen ELI Technology co.,ltd
000000-0FFFFF     (base 16)		Shenzhen ELI Technology co.,ltd
				Room 201, Dawning Building, No.12 Keji South 12th Road, Hi-Tech Park , Shenzhen
				Shenzhen  Guangdong  518057
				CN

88-5D-90   (hex)		Wuhan Strong Electronics Co., Ltd
400000-4FFFFF     (base 16)		Wuhan Strong Electronics Co., Ltd
				2nd Floor, 6 Bldg, Guannan Fuxing Medical Park,
				Wuhan  Hubei  430074
				CN

88-5D-90   (hex)		Schmidt & Co.,(H.K.)Ltd.
700000-7FFFFF     (base 16)		Schmidt & Co.,(H.K.)Ltd.
				5F., No.139, Songjiang Rd., Zhongshan Dist., Taipei City 10485, Taiwan (R.O.C.)
				Taipei  Taiwan  10485
				TW

88-5D-90   (hex)		iRoom GmbH
C00000-CFFFFF     (base 16)		iRoom GmbH
				Paracelsus Str. 4
				Oberndorf  Salzburg  5110
				AT

88-5D-90   (hex)		Premier Merchandises Limited
B00000-BFFFFF     (base 16)		Premier Merchandises Limited
				23/F Metro Loft, 38 Kwai Hei Street,
				Hong Kong    
				HK

74-F8-DB   (hex)		Provision-ISR
500000-5FFFFF     (base 16)		Provision-ISR
				11 Atir Yeda St.
				Kfar Saba  Israel  4464310
				IL

64-FB-81   (hex)		Kay Schulze & Karsten Pohle GbR
500000-5FFFFF     (base 16)		Kay Schulze & Karsten Pohle GbR
				Heinrich-Hertz-Strasse 121
				Hamburg  Hamburg  22083
				DE

64-FB-81   (hex)		NPG Technology S.A.
800000-8FFFFF     (base 16)		NPG Technology S.A.
				C/ Ecuador 14 (P.I. Las Monjas)
				Torrejón de Ardoz  Madrid  28850
				ES

80-7B-85   (hex)		Oliotalo Oy
B00000-BFFFFF     (base 16)		Oliotalo Oy
				Sinikalliontie 18 B
				Espoo  Uusimaa  02630
				FI

80-7B-85   (hex)		SMART ELECTRONICS NZ LIMITED
900000-9FFFFF     (base 16)		SMART ELECTRONICS NZ LIMITED
				4d Palm Grove, Berhampore
				Wellington    6023
				NZ

54-9A-11   (hex)		SpearX Inc.
100000-1FFFFF     (base 16)		SpearX Inc.
				No.332., Sec. 1, Jianguo S. Rd.,
				Taipei City    10656
				TW

64-FB-81   (hex)		Bronkhorst High-Tech BV
A00000-AFFFFF     (base 16)		Bronkhorst High-Tech BV
				Nijverheidsstraat 1a
				Ruurlo  Gelderland  NL-7261AK
				NL

80-E4-DA   (hex)		Elcus
900000-9FFFFF     (base 16)		Elcus
				Varshavskaya st. 5A lit L
				St.-Petersburg  St.-Petersburg  196128
				RU

64-FB-81   (hex)		Pricer AB
400000-4FFFFF     (base 16)		Pricer AB
				Västra Järnvägsgatan 7
				Stockholm    11164
				SE

1C-CA-E3   (hex)		PGA ELECTRONIC
100000-1FFFFF     (base 16)		PGA ELECTRONIC
				ZI LA MALTERIE
				MONTIERCHAUME    36130
				FR

64-FB-81   (hex)		MOBILUS Inc.
300000-3FFFFF     (base 16)		MOBILUS Inc.
				2nd Fl. 18,
				Seocho-gu  Seoul  138-898
				KR

1C-CA-E3   (hex)		Private
000000-0FFFFF     (base 16)		Private

90-C6-82   (hex)		Shenzhen Lencotion Technology Co.,Ltd
000000-0FFFFF     (base 16)		Shenzhen Lencotion Technology Co.,Ltd
				 LongGang,Buji Xia Shuijing,Hubei
				Shenzhen  Guangdong  518112
				CN

2C-D1-41   (hex)		CITA SMART SOLUTIONS LTD
E00000-EFFFFF     (base 16)		CITA SMART SOLUTIONS LTD
				5th Floor, 52-54 Gracechurch Street, London EC3V 0EH, United Kingdom
				London  N/L  EC3V 0EH
				GB

80-E4-DA   (hex)		Shortcut Labs
700000-7FFFFF     (base 16)		Shortcut Labs
				Teknikringen 26
				Stockholm  Stockholm  11428
				SE

80-E4-DA   (hex)		Wheatstone Corporation
000000-0FFFFF     (base 16)		Wheatstone Corporation
				600 Industrial Drive
				New Bern  NC  28562
				US

2C-D1-41   (hex)		Fiberroad Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Fiberroad Technology Co., Ltd.
				2F,5# Building,Minxing Industrial Park,MinKang Rd.Minzhi,Longhua District,ShenZhen China.
				shenzhen  GuangDong  518131
				CN

2C-D1-41   (hex)		ZENIC INC.
500000-5FFFFF     (base 16)		ZENIC INC.
				4-7-5
				Nionohama  Otsu Shiga  520-0801
				JP

2C-6A-6F   (hex)		Logic IO Aps
900000-9FFFFF     (base 16)		Logic IO Aps
				Holmboes Alle 14
				Horsens  DK  8700
				DK

2C-6A-6F   (hex)		SM DSP CO.,LTD.
700000-7FFFFF     (base 16)		SM DSP CO.,LTD.
				6-Gil 13-14
				Gumi-si  Gyeongsangbuk-Do  730-906
				KR

A0-BB-3E   (hex)		ManTech International Corporation
500000-5FFFFF     (base 16)		ManTech International Corporation
				2250 Corporate Park Drive
				Herndon  Virginia  20171
				US

A0-BB-3E   (hex)		Filo SRL
A00000-AFFFFF     (base 16)		Filo SRL
				Via Giovanni Giolitti 34
				Roma  rm  00185
				IT

98-02-D8   (hex)		Private
E00000-EFFFFF     (base 16)		Private

2C-6A-6F   (hex)		ELKO EP, s.r.o.
100000-1FFFFF     (base 16)		ELKO EP, s.r.o.
				Palackeho 493
				Holesov, Vsetuly  Zlinsky kraj  76901
				CZ

98-02-D8   (hex)		Zedi, Inc.
400000-4FFFFF     (base 16)		Zedi, Inc.
				1855 - 94 ST NW
				Edmonton  AB  T6N 1E6
				CA

98-02-D8   (hex)		Simplo Technology Co.,LTD
800000-8FFFFF     (base 16)		Simplo Technology Co.,LTD
				No471., Sec.2, Pa The Rd.,
				Hu Kou  30348  Hsin Chu Hsien
				TW

28-FD-80   (hex)		Airbus Defence and Space Oy
C00000-CFFFFF     (base 16)		Airbus Defence and Space Oy
				Hiomotie 32
				  Helsinki  00380
				FI

A0-BB-3E   (hex)		IVision Electronics Co.,Ltd
100000-1FFFFF     (base 16)		IVision Electronics Co.,Ltd
				Bldg.B,Yingkeli Industrial Park
				Shenzhen  GuangDong  518116
				CN

A0-BB-3E   (hex)		WiteRiver Technology LLC
300000-3FFFFF     (base 16)		WiteRiver Technology LLC
				31 Mira str.
				Ufa  Republic of Bashkortostan  450112
				RU

28-FD-80   (hex)		Zhixiang Technology Co., Ltd.
200000-2FFFFF     (base 16)		Zhixiang Technology Co., Ltd.
				7-2604 Media Village,
				Chaoyang District,  Beijing  100107
				CN

2C-26-5F   (hex)		Jiangsu JARI Technology Group Co., LTD
200000-2FFFFF     (base 16)		Jiangsu JARI Technology Group Co., LTD
				NO.18, Shenghu Rd,
				Lianyungang City  Jiangsu  222061
				CN

2C-26-5F   (hex)		Polara Engineering
A00000-AFFFFF     (base 16)		Polara Engineering
				9153 STELLAR COURT
				CORONA  California  92883
				US

0C-EF-AF   (hex)		GainStrong Industry Co.,Ltd
C00000-CFFFFF     (base 16)		GainStrong Industry Co.,Ltd
				3rd Floor, 1st Building, Block E, Minzhu West Industrial Zone, Bao’an Dist.
				Shenzhen  Guangdong  518100
				CN

0C-EF-AF   (hex)		chengdu joyotime Technology Co., Ltd.
A00000-AFFFFF     (base 16)		chengdu joyotime Technology Co., Ltd.
				room 503, B7 , tianfu software park
				chengdu  sichuan  610000
				CN

F8-02-78   (hex)		CLARUS Korea Co., Ltd
400000-4FFFFF     (base 16)		CLARUS Korea Co., Ltd
				 2F, Illutech Bldg, Myoenmok7-dong,
				   Seoul   131827
				KR

F8-02-78   (hex)		Rosemount Analytical
B00000-BFFFFF     (base 16)		Rosemount Analytical
				10241 West Little York, Suite 200
				Houston, TX 77040  Texas  77040
				US

A4-4F-29   (hex)		HTD
A00000-AFFFFF     (base 16)		HTD
				1000 Shiloh Rd, Suite 100
				Plano  TX  75074
				US

A4-4F-29   (hex)		GUANGDONG REAL-DESIGN INTELLIGENT TECHNOLOGY CO.,LTD
B00000-BFFFFF     (base 16)		GUANGDONG REAL-DESIGN INTELLIGENT TECHNOLOGY CO.,LTD
				No.1 Ruixiang Road,Fengxiang industrial Park,DaliangSub-district,Shunde district,Foshan City,Guangdong
				Foshan  Guangdong  528300
				CN

3C-39-E7   (hex)		VANSTONE ELECTRONIC (BEIJING)CO,. LTD.
C00000-CFFFFF     (base 16)		VANSTONE ELECTRONIC (BEIJING)CO,. LTD.
				Room 805,8/F,Qinghua Information Port Development Building,North High-tech Industrial Park,Nanshan District,Shenzhen
				shenzhen  guangdong  518000
				CN

A4-4F-29   (hex)		Dermalog Identification Systems GmbH
000000-0FFFFF     (base 16)		Dermalog Identification Systems GmbH
				Mittelweg 120
				Hamburg  Hamburg  20148
				DE

3C-39-E7   (hex)		Attrackting AG
500000-5FFFFF     (base 16)		Attrackting AG
				Falkenstrasse 44
				Biel/Bienne  Berne  2502
				CH

0C-EF-AF   (hex)		Goerlitz AG
100000-1FFFFF     (base 16)		Goerlitz AG
				August-Thyssen-Strasse 32
				Koblenz  Rheinland-Pfalz  56070
				DE

3C-39-E7   (hex)		Martem AS
800000-8FFFFF     (base 16)		Martem AS
				Akadeemia tee 21/6
				Tallinn  Harjumaa  12618
				EE

10-07-23   (hex)		BEIJING SOOALL INFORMATION TECHNOLOGY CO.,LTD
500000-5FFFFF     (base 16)		BEIJING SOOALL INFORMATION TECHNOLOGY CO.,LTD
				Room 1028,Block B,No.11 XinghuoRoad,Science City,Fengtai District
				Beijing  Beijing  100070
				CN

E8-18-63   (hex)		Protek Electronics Group Co.,LTD
B00000-BFFFFF     (base 16)		Protek Electronics Group Co.,LTD
				Homecare Technology Park,5/F,No.30,Langdong
				Shenzhen  Guangdong  518105
				CN

D0-22-12   (hex)		Spirit IT B.V.
000000-0FFFFF     (base 16)		Spirit IT B.V.
				prof. dr. Dorgelolaan 20
				Eindhoven  Noord-Brabant  5613 AM
				NL

D0-22-12   (hex)		Viatron GmbH
400000-4FFFFF     (base 16)		Viatron GmbH
				Carl-Metz-Str. 3
				Ettlingen  Baden Würtemberg  76275
				DE

B8-D8-12   (hex)		V5 Technology Corporation
400000-4FFFFF     (base 16)		V5 Technology Corporation
				5F., No.7, Lixing 3rd Rd., East Dist., Hsinchu City 30078, Taiwan (R.O.C.)
				HsinChu  Taiwan  30078
				TW

74-E1-4A   (hex)		Kanto Aircraft Instrument Co., Ltd.
900000-9FFFFF     (base 16)		Kanto Aircraft Instrument Co., Ltd.
				2-3-18 Honfujisawa
				Fujisawa  Kanagawa  251-0875
				JP

74-E1-4A   (hex)		APM Technologies (DongGuan) Ltd
700000-7FFFFF     (base 16)		APM Technologies (DongGuan) Ltd
				109Gosun Science Building, NanCheng , DongGuan, GuangDong, China
				DongGuan  GuangDong  523000
				CN

B8-D8-12   (hex)		Kiwigrid GmbH
A00000-AFFFFF     (base 16)		Kiwigrid GmbH
				Kleiststraße 10b
				Dresden  Saxony  01129
				DE

E4-95-6E   (hex)		Shanghai Tieda Telecommunications Equipment Co.,LTD.
D00000-DFFFFF     (base 16)		Shanghai Tieda Telecommunications Equipment Co.,LTD.
				18F The Sapphire Tower 267 TianmuRd(M)
				Shanghai  Zhabei District  200070
				

BC-66-41   (hex)		UtilLighting Co.,Ltd.
D00000-DFFFFF     (base 16)		UtilLighting Co.,Ltd.
				#102, 1F, 22, Samyang-ro, Seongbuk-gu, Seoul
				Seongbuk-gu  Seoul  136-717
				KR

E4-95-6E   (hex)		PT.MLWTelecom
800000-8FFFFF     (base 16)		PT.MLWTelecom
				Jalan Jembatan Dua Raya no.16/2
				  Jakarta  14450
				ID

E4-95-6E   (hex)		SMC Networks, Inc
000000-0FFFFF     (base 16)		SMC Networks, Inc
				20 Mason
				Irvine  CA  92618
				US

BC-66-41   (hex)		Global China Technology Limited
100000-1FFFFF     (base 16)		Global China Technology Limited
				Ruyi Road 1-3,Ailian, Longcheng Street, longgang Town,
				Shenzhen  GuangDong  518172
				CN

58-FC-DB   (hex)		Spang Power Electronics
000000-0FFFFF     (base 16)		Spang Power Electronics
				9305 Progress Parkway
				Mentor  Ohio  44060
				US

B0-1F-81   (hex)		Access Device Integrated Communications Corp.
C00000-CFFFFF     (base 16)		Access Device Integrated Communications Corp.
				No. 839, Sec.3, ChungChing Road,
				Taichung City  Taichung  42862
				TW

58-FC-DB   (hex)		Hi-Target Surveying Instrument Co., Ltd.
900000-9FFFFF     (base 16)		Hi-Target Surveying Instrument Co., Ltd.
				Plant 202, BLDG 13, Tian'An HQ Center, No.555 North Panyu RD. Donghuan Block,
				Guangzhou  Guangdong  511400
				CN

58-FC-DB   (hex)		Inforce Computing Inc.
400000-4FFFFF     (base 16)		Inforce Computing Inc.
				48820 Kato Road
				Fremont  CA  94538
				US

BC-66-41   (hex)		Intuitive Surgical, Inc
600000-6FFFFF     (base 16)		Intuitive Surgical, Inc
				1250 Kifer Rd
				Sunnyvale  California  94086
				US

14-1F-BA   (hex)		POS Systema LLC
E00000-EFFFFF     (base 16)		POS Systema LLC
				Varshavskoe shosse, 35, room №13
				Moscow  Moscow  117105
				RU

F4-0E-11   (hex)		BEIJING DONGJIN AERO-TECH CO., LTD
100000-1FFFFF     (base 16)		BEIJING DONGJIN AERO-TECH CO., LTD
				Building 7, 3th floor, Compound No. 33, Beiwaxili, Haidian District
				Beijing  Beijing  100089
				CN

B0-1F-81   (hex)		Aether Services, Inc.
700000-7FFFFF     (base 16)		Aether Services, Inc.
				1A2-A08, No.1, Lising 1st RD.
				Hsinchu City  Hsinchu  30078
				TW

F4-0E-11   (hex)		Kodpro Ltd.
A00000-AFFFFF     (base 16)		Kodpro Ltd.
				Room 801, 8/F, Opulent Bldg.,
				Hong Kong  Wan Chai  999077
				HK

14-1F-BA   (hex)		Wisnetworks Technologies Co., Ltd.
700000-7FFFFF     (base 16)		Wisnetworks Technologies Co., Ltd.
				No.77, FuTe West 3 Road, China
				  Shanghai  200000
				

7C-70-BC   (hex)		K-Vision Technology (Shanghai), Ltd
400000-4FFFFF     (base 16)		K-Vision Technology (Shanghai), Ltd
				Floor 4, No.9 Building, 879 Lane
				Shanghai  Shanghai  200333
				CN

7C-70-BC   (hex)		Nomad Digital Ltd.
700000-7FFFFF     (base 16)		Nomad Digital Ltd.
				2nd Floor, Baltic Chambers,
				Newcastle upon Tyne    NE1 3DQ
				GB

7C-70-BC   (hex)		Shanghai magcomm communication technology co ltd
000000-0FFFFF     (base 16)		Shanghai magcomm communication technology co ltd
				B Block,11F,Software Building, No 461 Hongcaolu
				Shanghai  Shanghai  200233
				CN

14-1F-BA   (hex)		BYZERO
400000-4FFFFF     (base 16)		BYZERO
				1222 Doosan Venture Digm
				Anyang-si  Gyeonggi-do  431-755
				KR

BC-34-00   (hex)		Q-PRODUCTS a. s.
700000-7FFFFF     (base 16)		Q-PRODUCTS a. s.
				Rybnicna 38/K
				Bratislava  SK  83106
				SK

BC-34-00   (hex)		Altronix Corporation
300000-3FFFFF     (base 16)		Altronix Corporation
				140 58th street 
				Brooklyn  NY  11220
				US

BC-34-00   (hex)		Redvision CCTV
000000-0FFFFF     (base 16)		Redvision CCTV
				17 Highview
				Bordon  Hampshire  GU35 0AX
				GB

A4-3B-FA   (hex)		Recognition Systems LLC
600000-6FFFFF     (base 16)		Recognition Systems LLC
				2380 Owen Street
				Santa Clara  CA  95054
				US

A4-3B-FA   (hex)		Deatronic srl
700000-7FFFFF     (base 16)		Deatronic srl
				Via Giulianello 1/7
				ROMA    00178
				IT

D0-76-50   (hex)		Private
400000-4FFFFF     (base 16)		Private

D0-76-50   (hex)		Accumulate AB
800000-8FFFFF     (base 16)		Accumulate AB
				Lästmakargatan 20
				  Stockholm  111 44
				SE

74-19-F8   (hex)		Starcor Beijing Co.,Limited
500000-5FFFFF     (base 16)		Starcor Beijing Co.,Limited
				NO.210 Block B, Building 2
				Beijing  Berijing  100089
				CN

74-19-F8   (hex)		Princip a.s.
900000-9FFFFF     (base 16)		Princip a.s.
				Radlicka 204/503
				Praha 5  Praha  158 00
				CZ

74-19-F8   (hex)		Tanjarine
A00000-AFFFFF     (base 16)		Tanjarine
				188 S Whisman Rd, Bldg A
				Mountain View  CA  94041
				US

74-19-F8   (hex)		Quest Payment Systems
800000-8FFFFF     (base 16)		Quest Payment Systems
				227 Burwood Road
				Hawthorn  Victoria  3122
				AU

74-19-F8   (hex)		Symtop Instrument Co.
200000-2FFFFF     (base 16)		Symtop Instrument Co.
				Haidianqu Xueqinglu Xuezhixuan 613
				Haidianqu  Beijing  100083
				CN

4C-4B-F9   (hex)		Electrolux Professional AB
A00000-AFFFFF     (base 16)		Electrolux Professional AB
				Ringvägen 14
				Ljungby    34180
				SE

40-11-75   (hex)		MIRC ELECTRONICS LTD
500000-5FFFFF     (base 16)		MIRC ELECTRONICS LTD
				Onida House, G-1, MIDC, Mahakali Caves Road, Andheri East
				Mumbai  Maharashtra  400093
				IN

40-11-75   (hex)		Table Trac Inc
400000-4FFFFF     (base 16)		Table Trac Inc
				6101 Baker Rd STE 206
				Minnetonka  MN  55345
				US

40-11-75   (hex)		Lexi Devices, Inc.
000000-0FFFFF     (base 16)		Lexi Devices, Inc.
				2342 Shattuck Ave, #260
				Berkeley    94704
				US

40-11-75   (hex)		NIBBLE
E00000-EFFFFF     (base 16)		NIBBLE
				Rua Julio Dinis 265 1D
				Trofa    4785-330
				PT

40-11-75   (hex)		Fujian Kuke3D Technology Co.,LTD
100000-1FFFFF     (base 16)		Fujian Kuke3D Technology Co.,LTD
				No.33, R&D Building, No. 1, Donghu Road, Digital Fujian Industrial Park, Changle District
				Fuzhou   Fujian  350200
				CN

10-DC-B6   (hex)		Pickering Interfaces Ltd
A00000-AFFFFF     (base 16)		Pickering Interfaces Ltd
				Stephenson Road
				Clacton On Sea  Essex  CO154NL
				GB

10-DC-B6   (hex)		Moya Commumication Technology (Shenzhen) Co.,Ltd.
700000-7FFFFF     (base 16)		Moya Commumication Technology (Shenzhen) Co.,Ltd.
				Guang Hui Science Park, No.17 of Min Qing Road, Longhua District
				Shenzhen    518000
				CN

54-A4-93   (hex)		Intelligent Surveillance Corp
000000-0FFFFF     (base 16)		Intelligent Surveillance Corp
				PO Box 12168
				College Station  TX  77842
				US

54-A4-93   (hex)		I-MOON TECHNOLOGY CO., LIMITED
300000-3FFFFF     (base 16)		I-MOON TECHNOLOGY CO., LIMITED
				FLAT/RM 2253, BLK 1, 22/F, HOI TAI FACTORY, EST TSING YEUNG CIRCUIT, TUEN MUN
				NT    999077
				HK

04-D1-6E   (hex)		Dspread Technology (Beijing) Inc.
500000-5FFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

04-D1-6E   (hex)		Evolute Systems Private Limited
E00000-EFFFFF     (base 16)		Evolute Systems Private Limited
				#3794 ,Ground and First Floor, 7th Main, Indira Nagar
				Bangalore  Karnataka  560038
				IN

44-03-77   (hex)		Exsom Computers LLC
200000-2FFFFF     (base 16)		Exsom Computers LLC
				Office 3206, The Citadel Tower, Business Bay
				Dubai  Dubai  72891
				AE

44-03-77   (hex)		SHEN ZHEN HUAWANG TECHNOLOGY CO; LTD
600000-6FFFFF     (base 16)		SHEN ZHEN HUAWANG TECHNOLOGY CO; LTD
				Longhua New District Qing Xiang Road, Bao Neng Technology Park
				SHEN ZHEN  GUANG DONG  518109
				CN

44-03-77   (hex)		Atari, Inc.
100000-1FFFFF     (base 16)		Atari, Inc.
				286 Madison Ave, 8th floor
				New York  NY  10017
				US

44-03-77   (hex)		Lenovo Image(Tianjin) Technology Ltd.
400000-4FFFFF     (base 16)		Lenovo Image(Tianjin) Technology Ltd.
				Tianjin Free Trade Test Zone (Airport Economic Zone) Room 310, No. 1, Second Avenue, Airport International Logistics Zone
				Tianjin  Tianjin  300000
				CN

44-03-77   (hex)		Bolin Technology Co., Ltd
E00000-EFFFFF     (base 16)		Bolin Technology Co., Ltd
				5/F, No 4 Block, Jinruizhonghe Industry Park,Huarong Road, Da Lang, Long Hua, Shenzhen, China.
				shenzhen  Guang Dong  518109
				CN

50-62-55   (hex)		COTT Electronics
D00000-DFFFFF     (base 16)		COTT Electronics
				71-75 Shelton Street
				London    WC2H 9JQ
				GB

50-62-55   (hex)		SHINSOFT CO., LTD.
E00000-EFFFFF     (base 16)		SHINSOFT CO., LTD.
				3F., No. 128, Xinhu 2nd Rd., Neihu Dist.
				Taipei City    114
				TW

1C-FD-08   (hex)		Cobham Slip Rings
900000-9FFFFF     (base 16)		Cobham Slip Rings
				18 Rue de Montréal
				ANNEMASSE  Ville-la-Grand  74108
				FR

C4-95-4D   (hex)		BA International Electronics Co. Ltd.
000000-0FFFFF     (base 16)		BA International Electronics Co. Ltd.
				8F., No. 140, Nanhua 1st St., Luzhu Dist.,
				Taoyuan City    338
				TW

C4-95-4D   (hex)		LLC TechnoEnergo
700000-7FFFFF     (base 16)		LLC TechnoEnergo
				Kemerovskaya str., 3
				Nizhny Novgorod  Nizhny Novgorod region  603152
				RU

C4-95-4D   (hex)		Xinjiang Golden Calf Energy IOT Technology Co., Ltd 
800000-8FFFFF     (base 16)		Xinjiang Golden Calf Energy IOT Technology Co., Ltd 
				A02 office building of Cloud Computing Industrial Park, Karamay District
				Karamay  Xinjiang  834000
				CN

C4-95-4D   (hex)		Teletronik AG
100000-1FFFFF     (base 16)		Teletronik AG
				Bahnhofstrasse 10.
				Zug    6302
				CH

C4-95-4D   (hex)		AKKA Germany GmbH
600000-6FFFFF     (base 16)		AKKA Germany GmbH
				Riesstrasse 14
				München  Bayern  80992
				DE

64-31-39   (hex)		Livongo Health
100000-1FFFFF     (base 16)		Livongo Health
				150 W. Evelyn Ave, Suite 150
				Mountain View  CA  94041
				US

C4-95-4D   (hex)		KAT Mekatronik Urunleri AS
A00000-AFFFFF     (base 16)		KAT Mekatronik Urunleri AS
				Istanbul Trakya Serbest Bolgesi Ataturk Bulvari No:20
				Istanbul  Catalca  34500
				TR

C4-95-4D   (hex)		GL Solutions Inc.
400000-4FFFFF     (base 16)		GL Solutions Inc.
				16-3 Kuramae 4-chome
				Taito-ku  Tokyo  111-0051
				JP

00-69-67   (hex)		miliwave
100000-1FFFFF     (base 16)		miliwave
				room 423,105 gwanggyo-ro, yengtong-gu
				suwon-si  Kyunggi-do  16229
				KR

00-69-67   (hex)		Comcast-SRL
600000-6FFFFF     (base 16)		Comcast-SRL
				Alejo Martinez 17
				Sosua  Puerto Plata  34443
				DO

00-69-67   (hex)		aversix
D00000-DFFFFF     (base 16)		aversix
				???????????351?4??7 (????)
				???  ???  235
				TW

00-69-67   (hex)		Ningbo Shen Link Communication Technology Co.,Ltd
200000-2FFFFF     (base 16)		Ningbo Shen Link Communication Technology Co.,Ltd
				No.87,Fengming Road,Lizhou Street
				Yuyao City  Zhejiang Province  315403
				CN

00-69-67   (hex)		Zhejiang Holip Electronic Technology Co.,Ltd
A00000-AFFFFF     (base 16)		Zhejiang Holip Electronic Technology Co.,Ltd
				NO.339 XINQIAO NORTH ROAD
				Haiyan  Zhejiang  314300
				CN

A0-22-4E   (hex)		Hunan Youmei Science&Technology Development Co.,Ltd.
E00000-EFFFFF     (base 16)		Hunan Youmei Science&Technology Development Co.,Ltd.
				3F, Building No.B8, Cultural Advertising Creative Industry Park, Economic Development Zone
				Huaihua City  Hunan Province  418000
				CN

A0-22-4E   (hex)		MESIT asd, s.r.o.
600000-6FFFFF     (base 16)		MESIT asd, s.r.o.
				Sokolovska 573
				Uherske Hradiste    686 01
				CZ

A0-22-4E   (hex)		Standartoptic, Limited Liability Company
C00000-CFFFFF     (base 16)		Standartoptic, Limited Liability Company
				Moskovsky p, 22nd kilometer Kievskoe highway, house 4, building 1 floor 9 Block B office 903?
				Moscow    108811
				RU

20-0A-0D   (hex)		Amazon Technologies Inc.
B00000-BFFFFF     (base 16)		Amazon Technologies Inc.
				P.O Box 8102
				Reno  NV  89507
				US

20-0A-0D   (hex)		Clearly IP Inc
300000-3FFFFF     (base 16)		Clearly IP Inc
				2416 Industrial Dr Unit F
				Neenah  WI  54956
				US

20-0A-0D   (hex)		Bently & EL  Co. Ltd.
D00000-DFFFFF     (base 16)		Bently & EL  Co. Ltd.
				7F-3, Fuxing North Road, Zhong Shan District
				Taipei    104
				TW

20-0A-0D   (hex)		Austin Hughes Electronics Ltd.
600000-6FFFFF     (base 16)		Austin Hughes Electronics Ltd.
				Unit 3608-12, Cable TV Tower, 9 Hoi Shing Road, Tsuen Wan,  Hong Kong
				Hong Kong  Kwai Tsing New Territories  00000
				HK

20-0A-0D   (hex)		HANGZHOU DANGBEI NETWORK TECH.Co.,Ltd
E00000-EFFFFF     (base 16)		HANGZHOU DANGBEI NETWORK TECH.Co.,Ltd
				Build C,Wanfu Center,Binkang Road No.228,Binjiang Area
				China    210051
				CN

40-2C-76   (hex)		Beijing Smarot Technology Co., Ltd.
400000-4FFFFF     (base 16)		Beijing Smarot Technology Co., Ltd.
				Room 505, unit 2, 5th floor, 12th building, 3rd yard , Kangze road, Fangshan district
				Beijing  Beijing  102488
				CN

40-2C-76   (hex)		Shanghai Dahua Scale Factory
100000-1FFFFF     (base 16)		Shanghai Dahua Scale Factory
				No.1013 Wangqiao Road,Pudong New District
				Shanghai  Shanghai  201201
				CN

50-DE-19   (hex)		Tianjin Natianal Health Technology Co.,Ltd
700000-7FFFFF     (base 16)		Tianjin Natianal Health Technology Co.,Ltd
				Room 2-6, No.8, Haitai development fifth Road, Huayuan industrial Zone , Binhai high-tech District
				Tianjin  Tianjin  300450
				CN

50-DE-19   (hex)		AEG Identifikationssysteme GmbH
900000-9FFFFF     (base 16)		AEG Identifikationssysteme GmbH
				Hörvelsinger Weg 47
				Ulm    89081
				DE

50-DE-19   (hex)		SPII SPA
200000-2FFFFF     (base 16)		SPII SPA
				VIA D. VOLPI 37 - ANGOLO VIA MONTOLI
				SARONNO  VARESE  21047
				IT

50-A4-D0   (hex)		TRAXENS
000000-0FFFFF     (base 16)		TRAXENS
				HELIOPOLIS III – 16 rue Louis Leprince Ringuet
				Marseille  Provence-Alpes-Côte d'Azur  13013
				FR

50-DE-19   (hex)		TRAXENS
300000-3FFFFF     (base 16)		TRAXENS
				HELIOPOLIS III – 16 rue Louis Leprince Ringuet
				Marseille  Provence-Alpes-Côte d'Azur  13013
				FR

3C-FA-D3   (hex)		LIPS Corporation
700000-7FFFFF     (base 16)		LIPS Corporation
				2F., No. 100, Ruiguang Rd., Neihu Dist.
				Taipei  Taiwan  114
				TW

50-DE-19   (hex)		Tannak International AB
A00000-AFFFFF     (base 16)		Tannak International AB
				 Midgårdsvägen 13
				Luleå     973 34
				SE

3C-FA-D3   (hex)		Annapurna labs
100000-1FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

3C-FA-D3   (hex)		 Corelink Technology Co.,Ltd
B00000-BFFFFF     (base 16)		 Corelink Technology Co.,Ltd
				2701, building D2, No.1, Keyuan Weiyi Road, Laoshan District
				Qingdao  Shandong  China
				CN

3C-FA-D3   (hex)		Shenzhen Vplus Communication Intelligent Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen Vplus Communication Intelligent Co., Ltd.
				Bao'an
				Shenzhen  Guangdong  518000
				CN

B0-B3-53   (hex)		WUUK LABS CORP.
700000-7FFFFF     (base 16)		WUUK LABS CORP.
				16192 COASTAL HWY
				LEWES  DE  19958
				US

B0-B3-53   (hex)		Nanjing Yining Intelligent Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Nanjing Yining Intelligent Technology Co., Ltd.
				Room 209-114, 2 / F, Building 04, No. 18 Jialingjiang East Street, Jianye District, Nanjing
				Nanjing  Jiangsu  210019
				CN

B0-B3-53   (hex)		Blake UK
000000-0FFFFF     (base 16)		Blake UK
				177-187, Rutland Road
				Sheffield  --select--  S3 9PT
				GB

B0-B3-53   (hex)		Beijing Geekplus Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Beijing Geekplus Technology Co.,Ltd.
				1st Floor, Building 1, Chaolai High-Tech industrial Part, Chaoyang District
				Beijing   Beijing   100012
				CN

B0-B3-53   (hex)		IPvideo Corporation
D00000-DFFFFF     (base 16)		IPvideo Corporation
				1490 North Clinton Ave
				Bay Shore  NY  11706
				US

B0-B3-53   (hex)		Zoox
B00000-BFFFFF     (base 16)		Zoox
				1149 Chess Drive
				Foster City  CA  94404
				US

14-AE-85   (hex)		Qingdao iTechene Technologies Co., Ltd.
200000-2FFFFF     (base 16)		Qingdao iTechene Technologies Co., Ltd.
				UnitA3-A4,Level8,Block A ,International Innovation Park,No.1Keyuanwei Rd.,Laoshan District
				Qingdao    266100
				CN

14-AE-85   (hex)		Henfred Technology Co., Ltd.
100000-1FFFFF     (base 16)		Henfred Technology Co., Ltd.
				3F.-7, No.77, Sec. 1, Xintai 5th Rd
				New Taipei City  Xizhi Dist  221
				TW

64-62-66   (hex)		Annapurna labs
100000-1FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

14-AE-85   (hex)		MTA Systems
A00000-AFFFFF     (base 16)		MTA Systems
				Pemstraße 2
				Mauthausen    4310
				AT

64-62-66   (hex)		Bühler AG
500000-5FFFFF     (base 16)		Bühler AG
				Gupfenstrasse 5
				Uzwil    9240
				CH

64-62-66   (hex)		MiiVii Dynamics Technology CO.,LTD
000000-0FFFFF     (base 16)		MiiVii Dynamics Technology CO.,LTD
				1408-1415 Tower A BUGG Building,No.18 N. Taipingzhuang Rd,haidian District
				Beijing  Beijing  100000
				CN

64-62-66   (hex)		Shenzhen Jie Shi Lian Industrial Co., LTD
E00000-EFFFFF     (base 16)		Shenzhen Jie Shi Lian Industrial Co., LTD
				6F,C Building,Jinao Industrial Park,Juling Rd,Guanlan Town,Longhua
				Shenzhen  Guangdong  518000
				CN

64-62-66   (hex)		Leontech Limited
800000-8FFFFF     (base 16)		Leontech Limited
				1208 WorkingBerg Commercial Buildung, 41-47 Marble Road
				Hong Kong  Hong Kong  00000
				HK

94-CC-04   (hex)		Hanzhuo Information Technology(Shanghai) Ltd.
D00000-DFFFFF     (base 16)		Hanzhuo Information Technology(Shanghai) Ltd.
				Room 2085, building 2, 622 Yingyuan middle Road, Jiading Strict
				Shanghai    201200
				CN

94-CC-04   (hex)		Sam Nazarko Trading Ltd
600000-6FFFFF     (base 16)		Sam Nazarko Trading Ltd
				18 Watermill Way
				London  Surrey  SW19 2RD
				GB

94-CC-04   (hex)		hyBee Inc.
A00000-AFFFFF     (base 16)		hyBee Inc.
				#1003, Innovalley B, 253, Pangyo-ro, Bundang-gu
				Seongnam-si  Gyeonggi-do  13486
				KR

94-CC-04   (hex)		Nanjing Yacer Communication Technology Co. Ltd.
200000-2FFFFF     (base 16)		Nanjing Yacer Communication Technology Co. Ltd.
				333 Taiping South Road Jinling Yujingyuan 19nd  floor Unit K Qin Huai District
				nanjing  jiangsu  210000
				CN

90-E2-FC   (hex)		Pars Ertebat Afzar Co.
000000-0FFFFF     (base 16)		Pars Ertebat Afzar Co.
				1116 – Burlington Tower Business Bay
				Dubai    90072
				AE

94-05-BB   (hex)		iungo
800000-8FFFFF     (base 16)		iungo
				Vrouwenlaan 62
				Zwolle  Overijssel  8017 HS
				NL

94-05-BB   (hex)		Qingdao Maotran Electronics co., ltd
000000-0FFFFF     (base 16)		Qingdao Maotran Electronics co., ltd
				Room2907, Building 2 of Minghui International, No.39 of Shiling Road, Laoshan District
				Qingdao  Shandong  266000
				CN

94-05-BB   (hex)		Dongguan CXWE Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Dongguan CXWE Technology Co.,Ltd.
				Room 805, building 1, No. 16, Keji 4th Road, Songshanhu
				Dongguan  Guangdong  523000
				CN

F4-90-CB   (hex)		Cheetah Medical
C00000-CFFFFF     (base 16)		Cheetah Medical
				2A Hashlosha st.
				Tel Aviv    6706055
				IL

94-05-BB   (hex)		Zimmer GmbH
900000-9FFFFF     (base 16)		Zimmer GmbH
				Im Salmenkopf 5
				Rheinau  Baden-Württemberg  77866
				DE

94-05-BB   (hex)		BAE Systems
E00000-EFFFFF     (base 16)		BAE Systems
				21 continental boulevard
				Merrimack  NH  03054
				US

F4-90-CB   (hex)		A-dec Inc.
B00000-BFFFFF     (base 16)		A-dec Inc.
				2601 Crestview Drive
				Newberg  OR  97132
				US

C0-9B-F4   (hex)		LTD Delovoy Office
600000-6FFFFF     (base 16)		LTD Delovoy Office
				Block “B”, floor 6, build 4/1, Stroiteley blvd
				Krasnogorsk    143401
				RU

F4-90-CB   (hex)		TEQ SA
700000-7FFFFF     (base 16)		TEQ SA
				Via al Municipio 16
				Barbengo  Ticino  6917
				CH

A4-DA-22   (hex)		Grundig
A00000-AFFFFF     (base 16)		Grundig
				Steinhof 39
				Erkrath   North Rhine-Westphalia  40699
				DE

E8-B4-70   (hex)		YAWATA ELECTRIC INDUSTRIAL CO.,LTD.
400000-4FFFFF     (base 16)		YAWATA ELECTRIC INDUSTRIAL CO.,LTD.
				1-17-1 Ohmorihigashi
				Ohta-ku  Tokyo  143-0012
				JP

E8-B4-70   (hex)		Tibit Communications
700000-7FFFFF     (base 16)		Tibit Communications
				1 Willowbrook Court, Suite 150
				Petaluma  CA  94954
				US

94-FB-A7   (hex)		Shanghai Hyco Genyong Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shanghai Hyco Genyong Technology Co., Ltd.
				Room 105, 1/F, Building B, No.999 of Huaxu Road, Qingpu District, Shanghai, China
				Shanghai    201702
				CN

94-FB-A7   (hex)		UOI TECHNOLOGY CORPORATION
400000-4FFFFF     (base 16)		UOI TECHNOLOGY CORPORATION
				1F., No. 50, Ln. 148, Lide St.
				Zhonghe Dist.  New Taipei City  23512
				TW

38-F7-CD   (hex)		VANGUARD
300000-3FFFFF     (base 16)		VANGUARD
				1st Floor 3 Moore 
				London    SE1 2RE
				GB

38-F7-CD   (hex)		RIPower Co.,Ltd
200000-2FFFFF     (base 16)		RIPower Co.,Ltd
				3F,1,Bongeunsa-ro 44-gil, Gangnam-gu
				Seoul    06143
				KR

38-F7-CD   (hex)		Fibergate Inc.
B00000-BFFFFF     (base 16)		Fibergate Inc.
				KDX Shibadaimon.Bld 2F 2-10-12 Shibadaimon
				Tokyo  Minato-ku  1050012
				JP

94-FB-A7   (hex)		Reichert Inc.
000000-0FFFFF     (base 16)		Reichert Inc.
				3362 Walden Ave
				Depew  NY  14043
				US

38-F7-CD   (hex)		Fast Cotton(Beijing) Limited
600000-6FFFFF     (base 16)		Fast Cotton(Beijing) Limited
				Fast Cotton(Beijing)Limited
				Beijing  Beijing  100037
				CN

70-69-79   (hex)		Rivian Automotive LLC
C00000-CFFFFF     (base 16)		Rivian Automotive LLC
				13250 N. Haggerty Road
				Plymouth  MI  48170
				US

70-69-79   (hex)		Foxconn Brasil Industria e Comercio Ltda
A00000-AFFFFF     (base 16)		Foxconn Brasil Industria e Comercio Ltda
				Av. Marginal da Rodovia dos Bandeirantes, 800 - Distrito Industrial
				Jundiaí  Sao Paulo  13213-008
				BR

70-69-79   (hex)		SelectTech GeoSpatial, LLC
400000-4FFFFF     (base 16)		SelectTech GeoSpatial, LLC
				8045 Washington Village Dr.
				Centerville  OH  45458
				US

F0-D7-AF   (hex)		720?bei jing?Health iTech Co.,Ltd
300000-3FFFFF     (base 16)		720?bei jing?Health iTech Co.,Ltd
				Room 9001, D Building, Kangjianbaosheng Plaza, No.8 Heiquan Road, Haidian District, Beijing
				bei jing    100085
				CN

F0-D7-AF   (hex)		EVCO SPA
B00000-BFFFFF     (base 16)		EVCO SPA
				VIA FELTRE N. 81
				SEDICO  BELLUNO  32036
				IT

F0-D7-AF   (hex)		Rievtech Electronic Co.,Ltd 
700000-7FFFFF     (base 16)		Rievtech Electronic Co.,Ltd 
				Room 505, Building A, No.88,Dazhou Road,Tiexinqiao,Yu huatai District, Nanjing City, Jiangsu Province,P.R.China +0086 25 52895099                 52890138 info@rievtech.com sales@rievtech.com
				Nanjing City  Jiangsu Province  210000
				CN

F0-D7-AF   (hex)		Shenzhen Virtual Clusters Information Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Shenzhen Virtual Clusters Information Technology Co.,Ltd.
				Room 201,Building A,No.1,Qianhai 1st Road,Shengang cooperation zone,Qianhai
				Shenzhen    518054
				CN

AC-1D-DF   (hex)		FINEpowerX INC
B00000-BFFFFF     (base 16)		FINEpowerX INC
				Rm 2208, U-Tower, 120 HeungDeok JungAng-ro, GiHeung-Gu
				YongIn-si  Gyeonggi-do  16950
				KR

30-49-50   (hex)		ATLI WORLD LIMITED
100000-1FFFFF     (base 16)		ATLI WORLD LIMITED
				306 Beverley Commercial Center, 87-105 Chatham Road, TST,
				Kowloon  Hong Kong  852
				HK

30-49-50   (hex)		Anacove LLC
C00000-CFFFFF     (base 16)		Anacove LLC
				7856 Revelle drive
				LA JOLLA  CA  92037
				US

30-49-50   (hex)		Ledworks SRL
A00000-AFFFFF     (base 16)		Ledworks SRL
				Via Tortona 37
				Milano  Milano  20144
				IT

D0-D9-4F   (hex)		Mitsubishi Electric US, Inc.
700000-7FFFFF     (base 16)		Mitsubishi Electric US, Inc.
				1340 Satellite Boulevard
				Suwanee  GA  30345
				US

30-49-50   (hex)		Sercomm Corporation.
200000-2FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

D0-14-11   (hex)		powerall
400000-4FFFFF     (base 16)		powerall
				75,Ojeong-ro,Bucheon-si,Gyeonggi-do,Republic of korea
				Gyeonggi-do province    14445
				KR

D0-14-11   (hex)		ABB EVI SPA
A00000-AFFFFF     (base 16)		ABB EVI SPA
				VIA DI SAN GIORGIO, 642
				TERRANUOVA BRACCIOLINI  AREZZO  52028
				IT

D0-14-11   (hex)		Airthings
900000-9FFFFF     (base 16)		Airthings
				Wergelandsveien 7
				Oslo    0167
				NO

F4-69-D5   (hex)		ShenZhenShi EVADA technology Co.,Ltd
A00000-AFFFFF     (base 16)		ShenZhenShi EVADA technology Co.,Ltd
				Qianhai,No.1 qianwan Road
				ShenZhen  Guangdong  518000
				CN

F4-69-D5   (hex)		Mossman Limited
000000-0FFFFF     (base 16)		Mossman Limited
				1014, 10/F, Leader Industrial Building,
				57-59 Au Pui Wan Street, Fotan, Shatin  Hong Kong  NT
				HK

5C-85-7E   (hex)		Shenzhen IP3 Century Intelligent Technology CO.,Ltd
400000-4FFFFF     (base 16)		Shenzhen IP3 Century Intelligent Technology CO.,Ltd
				aiying.li@ip3-tech.com
				Shenzhen    518057
				CN

5C-85-7E   (hex)		Shanghai Yanhe automation technology co.,LTD
500000-5FFFFF     (base 16)		Shanghai Yanhe automation technology co.,LTD
				Room E2204, Building 1, 5500 Yuan Jiang Road, MinHang District
				ShangHai    201100
				CN

5C-85-7E   (hex)		ProdataKey
600000-6FFFFF     (base 16)		ProdataKey
				67 W 13490 S
				Draper  UT  84020
				US

F4-69-D5   (hex)		Huaqin Telecom Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Huaqin Telecom Technology Co.,Ltd.
				Building 1,No.399, Keyuan Road, Pudong, Shanghai China
				Shanghai    200120
				CN

F4-69-D5   (hex)		Pulsar Engineering srl
200000-2FFFFF     (base 16)		Pulsar Engineering srl
				Via Giuseppe Caimi
				Milano  MI  20136
				IT

F4-69-D5   (hex)		Rosco, Inc
700000-7FFFFF     (base 16)		Rosco, Inc
				90-21 144th Place
				Jamaica  NY  11435
				US

4C-93-A6   (hex)		Private
500000-5FFFFF     (base 16)		Private

4C-93-A6   (hex)		Diehl Controls Nanjing Co., Ltd.
200000-2FFFFF     (base 16)		Diehl Controls Nanjing Co., Ltd.
				Jiangjun Avenue 139
				Nanjing  Jiangsu  211100
				CN

4C-93-A6   (hex)		Commsignia, Ltd.
300000-3FFFFF     (base 16)		Commsignia, Ltd.
				Irinyi Jozsef u 4-20
				Budapest    1117
				HU

28-B7-7C   (hex)		Shenzhen PUAS Industrial Co.,LTD
800000-8FFFFF     (base 16)		Shenzhen PUAS Industrial Co.,LTD
				2/F, C/Building, Huawang Industrial Park, LongHua New Area In Shenzhen 518106 P.R.C
				Shenzhen  Guangdong  518106
				CN

28-B7-7C   (hex)		SolarEdge Technologies
100000-1FFFFF     (base 16)		SolarEdge Technologies
				1 Abba Eban St.
				Herzelia    46725
				IL

C0-61-9A   (hex)		MAD PIECE LLC.
700000-7FFFFF     (base 16)		MAD PIECE LLC.
				2196 flatbush ave.
				BROOKLYN  NY  11234
				US

C0-61-9A   (hex)		Nanjing Balance Network Technology Co., Ltd
500000-5FFFFF     (base 16)		Nanjing Balance Network Technology Co., Ltd
				9-10/F,building 01, No.8,Bailongjiang East Street,Jianye District
				Nanjing  Jiangsu  210017
				CN

C0-61-9A   (hex)		Uhnder
D00000-DFFFFF     (base 16)		Uhnder
				3409 Executive Center Drive Ste205
				Austin  TX  78731
				US

98-FC-84   (hex)		Jazwares LLC
D00000-DFFFFF     (base 16)		Jazwares LLC
				1067 Shotgun Rd
				Sunrise  FL  33326
				US

98-FC-84   (hex)		Sferrum GmbH
400000-4FFFFF     (base 16)		Sferrum GmbH
				Kytyzovsky avenue, build 36/3, office 216
				Moscow    121170
				RU

98-FC-84   (hex)		Shenzhen Incar Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Shenzhen Incar Technology Co., Ltd.
				Zhongxi ECO International Building, Shuiku Rd., Baoan District
				Shenzhen     518000
				CN

98-FC-84   (hex)		Leia, Inc
000000-0FFFFF     (base 16)		Leia, Inc
				2440 Sand Hill Road, STE 100, Menlo Park
				Menlo Park  CA  94025
				US

18-FD-CB   (hex)		Staclar, Inc.
300000-3FFFFF     (base 16)		Staclar, Inc.
				2093 Philadelphia Pike
				Claymont  DE  19703
				US

18-FD-CB   (hex)		Ark Vision Systems GmbH & Co. KG
C00000-CFFFFF     (base 16)		Ark Vision Systems GmbH & Co. KG
				Limburger Str., 51
				Merenberg  Hessen  35799
				DE

18-FD-CB   (hex)		KWANG YANG MOTOR CO.,LTD
E00000-EFFFFF     (base 16)		KWANG YANG MOTOR CO.,LTD
				NO. 35, WAN HSING ST., SAN MIN DIST., KAOHSIUNG, TAIWAN, R.O.C
				Kaohsiung    807
				TW

D0-14-11   (hex)		CYLTek Limited
B00000-BFFFFF     (base 16)		CYLTek Limited
				R603,6F.,NO.168,Sec.2,Fuxing 3rd.Rd.
				Zhubei City,Hsinchu County    30273
				TW

18-FD-CB   (hex)		SKA Organisation
600000-6FFFFF     (base 16)		SKA Organisation
				Jodrell Bank, Lower Withington
				Macclesfield  Cheshire  SK11 9FT
				GB

CC-4F-5C   (hex)		Smiths US Innovation LLC
700000-7FFFFF     (base 16)		Smiths US Innovation LLC
				3125 SKYWAY CT
				Fremont  CA  94539
				US

CC-4F-5C   (hex)		Ontex BV
B00000-BFFFFF     (base 16)		Ontex BV
				Genthof 5
				Buggenhout  NA  9255
				BE

CC-4F-5C   (hex)		Spark Biomedical
400000-4FFFFF     (base 16)		Spark Biomedical
				4428 Irvin Simmons Drive
				Dallas  TX  75229
				US

CC-4F-5C   (hex)		lesswire GmbH
100000-1FFFFF     (base 16)		lesswire GmbH
				Rudower Chaussee 30
				Berlin  Germany  12489
				DE

CC-4F-5C   (hex)		Beijing Cotytech Technology Co.,LTD.
C00000-CFFFFF     (base 16)		Beijing Cotytech Technology Co.,LTD.
				Rm2302,Block B,Haojing Building,Zhichunlu,Haidian District,Beijing
				Beijing    100192
				CN

CC-4F-5C   (hex)		Watertech S.p.A.
600000-6FFFFF     (base 16)		Watertech S.p.A.
				STRADA ANTICA FORNACE 2/4
				CANELLI  ITALY  14053
				IT

FC-CD-2F   (hex)		Ningbo Bull Digital Technology Co., LTD
000000-0FFFFF     (base 16)		Ningbo Bull Digital Technology Co., LTD
				No.32 Sanhai Road, East Guanhaiwei Industrial zone
				Cixi City  Zhejiang   315314
				CN

58-95-D8   (hex)		Loftie
900000-9FFFFF     (base 16)		Loftie
				26 Grove St, Apt. 5C
				New York  NY  10014
				US

58-95-D8   (hex)		Peak Communications Limited
A00000-AFFFFF     (base 16)		Peak Communications Limited
				Suite 1, Commercial House One, Eden Island, Republic of Seychelles
				Eden Island    123
				SC

58-95-D8   (hex)		Shenzhen DOOGEE Hengtong Technology CO.,LTD
000000-0FFFFF     (base 16)		Shenzhen DOOGEE Hengtong Technology CO.,LTD
				Shenzhen DOOGEE Hengtong Technology CO.,LTD
				Shenzhen  Guangdong  518000
				CN

58-95-D8   (hex)		Norgren Manufacturing Co., Ltd.
600000-6FFFFF     (base 16)		Norgren Manufacturing Co., Ltd.
				Block 3, No 1885 Duhui Road, Minhang District
				Shanghai  Shanghai  201108
				CN

DC-4A-9E   (hex)		Methodex Systems Pvt. Ltd.
800000-8FFFFF     (base 16)		Methodex Systems Pvt. Ltd.
				607-8 Meghdoot, 94 Nehru Place
				New Delhi  Delhi  110019
				IN

DC-4A-9E   (hex)		Astrogate Inc.
700000-7FFFFF     (base 16)		Astrogate Inc.
				11F-6, No. 120, Qiaohe Rd., Zhonghe Dist.
				New Taipei City    235
				TW

58-95-D8   (hex)		LOCTEK ERGONOMIC TECHNOLOGY CORP.
C00000-CFFFFF     (base 16)		LOCTEK ERGONOMIC TECHNOLOGY CORP.
				No. 588, Qihang South Road, Yinzhou Economic Development Zone
				Ningbo City  Zhejiang  315100
				CN

DC-4A-9E   (hex)		TATTILE SRL
600000-6FFFFF     (base 16)		TATTILE SRL
				VIA DONIZETTI, 1/3/5
				MAIRANO  BRESCIA  25030
				IT

DC-4A-9E   (hex)		HAPPIEST BABY INC.
D00000-DFFFFF     (base 16)		HAPPIEST BABY INC.
				3115 S La Cienega Blvd.
				Los Angeles  CA  90016
				US

84-11-C2   (hex)		Kazdream Technologies LLP
000000-0FFFFF     (base 16)		Kazdream Technologies LLP
				10, Turkestan Str.
				Nur-Sultan    010000
				KZ

84-11-C2   (hex)		LLC STC MZTA
400000-4FFFFF     (base 16)		LLC STC MZTA
				33/26 Mironovskaya str.
				Moscow  Moscow  115280
				RU

84-11-C2   (hex)		Futurecom Systems Group
200000-2FFFFF     (base 16)		Futurecom Systems Group
				3277 Langstaff Rd
				Concord  Ontario  L4K 5P8
				CA

68-79-12   (hex)		Copper Labs, Inc.
500000-5FFFFF     (base 16)		Copper Labs, Inc.
				3015 Sterling Circle #200
				Boulder  CO  80301
				US

68-79-12   (hex)		Wingtech Mobile Communications Co., Ltd.
A00000-AFFFFF     (base 16)		Wingtech Mobile Communications Co., Ltd.
				No.777,Yazhong Road,Nanhu District,
				Jiaxing  Zhejiang  314006
				CN

68-79-12   (hex)		CNDI CO.,LTD
200000-2FFFFF     (base 16)		CNDI CO.,LTD
				33-13, EUNHAENG-RO, 218 BEON-GIL
				SIHEUNG-SI  GYEONGGI-DO  14908
				KR

68-79-12   (hex)		Swisscom Broadcast Ltd
B00000-BFFFFF     (base 16)		Swisscom Broadcast Ltd
				Ostermundigenstrasse 99
				Bern    3050
				CH

8C-47-6E   (hex)		Chipsafer Pte. Ltd.
000000-0FFFFF     (base 16)		Chipsafer Pte. Ltd.
				2 Changi South Lane
				Singapore    486123
				SG

8C-47-6E   (hex)		HuiZhou MIKI Communication Equipment Co.,LTD
200000-2FFFFF     (base 16)		HuiZhou MIKI Communication Equipment Co.,LTD
				NO.39,GuangTai Road HuiNan HI-techindustrial Park.Zhongkai Hi-tech Zone
				Huizhou    516000
				CN

8C-47-6E   (hex)		Xertified AB
900000-9FFFFF     (base 16)		Xertified AB
				Horisontvagen 60
				Stockholm  Stockholm  12830
				SE

34-04-9E   (hex)		ClearCaptions LLC
C00000-CFFFFF     (base 16)		ClearCaptions LLC
				595 Menlo Drive
				Rocklin   CA  95765
				US

8C-AE-49   (hex)		Gigawave
A00000-AFFFFF     (base 16)		Gigawave
				Unit 4 Metro Business Park, ballycurreen
				cork    T12 HP60
				IE

8C-AE-49   (hex)		TTR Corporation
900000-9FFFFF     (base 16)		TTR Corporation
				20-1 Iwaoshi-machi
				Takasaki-shi  Gunma  370-0044
				JP

8C-AE-49   (hex)		Chengdu BillDTE Technology Co., Ltd
600000-6FFFFF     (base 16)		Chengdu BillDTE Technology Co., Ltd
				Chengdu BiiDTE Technology Co.,Ltd
				Chengdu  Sichuan  610041
				CN

8C-AE-49   (hex)		Precitec Optronik GmbH
700000-7FFFFF     (base 16)		Precitec Optronik GmbH
				Schleussnerstraße 54
				Neu-Isenburg  Hessen  63263
				DE

8C-AE-49   (hex)		Parametric GmbH
C00000-CFFFFF     (base 16)		Parametric GmbH
				Waldeggstrasse 82
				Interlaken  BE  3800
				CH

8C-AE-49   (hex)		LLC Taipit - Measuring Equipment
800000-8FFFFF     (base 16)		LLC Taipit - Measuring Equipment
				Voroshilova, 2
				Saint-Petersburg    193318
				RU

A4-53-EE   (hex)		Stellamore
100000-1FFFFF     (base 16)		Stellamore
				Room 1519, 15th Floor, Block A, Economic Building, Baoyuan Huafeng Headquarters, No. 288, Xixiang Avenue, Bao'an District
				Shenzhen  Guangdong  518100
				CN

8C-AE-49   (hex)		Shenzhen C & D Electronics Co., Ltd.
E00000-EFFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

A4-53-EE   (hex)		Dongguan HuaFuu industrial co., LTD
900000-9FFFFF     (base 16)		Dongguan HuaFuu industrial co., LTD
				Huafuu technology park,jinggangzhong Road,shatian
				Dongguan  Guangdong  523841
				CN

A4-53-EE   (hex)		Ubisafe Smart Devices
200000-2FFFFF     (base 16)		Ubisafe Smart Devices
				Getulio Vargas 2729
				Sao Jose  SC  88103-400
				BR

4C-93-A6   (hex)		4TheWall - 4D Sistem A.S
400000-4FFFFF     (base 16)		4TheWall - 4D Sistem A.S
				Oran Mah. Turan Gunes Bul. Park Oran Ofis 180-Y No:6 Cankaya 
				ANKARA    06550
				TR

A0-02-4A   (hex)		Xiaojie Technology (Shenzhen) Co., Ltd
600000-6FFFFF     (base 16)		Xiaojie Technology (Shenzhen) Co., Ltd
				801#, Block B1,Kexing Secience Park, Hi-Tech Industrial Park, Nanshan District
				Shenzhen  Guangdong  518000
				CN

78-D4-F1   (hex)		Huaqin Telecom Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Huaqin Telecom Technology Co.,Ltd.
				Building 1,No.399, Keyuan Road, Pudong, Shanghai China
				Shanghai    200120
				CN

78-D4-F1   (hex)		shanghai baudcom communication device co.,ltd
900000-9FFFFF     (base 16)		shanghai baudcom communication device co.,ltd
				519A, Building A, Lianming Road 389, Minhang District
				shanghai  shanghai  201101
				CN

78-D4-F1   (hex)		BYD Auto lndustry Co.,Ltd
400000-4FFFFF     (base 16)		BYD Auto lndustry Co.,Ltd
				No.3009 BYD Road, Building D23, BYD EPRI, PingShan District, 
				ShenZhen  GuangDong  518118  
				CN

78-D4-F1   (hex)		Famar Fueguina S.A.
700000-7FFFFF     (base 16)		Famar Fueguina S.A.
				Rodney 70
				Buenos Aires    1427
				AR

44-6F-D8   (hex)		Sichuan subao network technology ltd.co.
000000-0FFFFF     (base 16)		Sichuan subao network technology ltd.co.
				No. 704 Room ,  No. 599 South Century Town Road, High technology district, Chengdu 
				chengdu  sichuan Province  610094
				CN

44-6F-D8   (hex)		ZHEJIANG SHIP ELECTRONICS & TECHNOLOGY CO., LTD.
500000-5FFFFF     (base 16)		ZHEJIANG SHIP ELECTRONICS & TECHNOLOGY CO., LTD.
				#6 GAOYA RD
				NINGBO  ZHEJIANG PROVINCE  315191
				CN

44-6F-D8   (hex)		Changzhou Haitu Electronic Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Changzhou Haitu Electronic Technology Co.,Ltd
				Building 47, Hang Seng Science park, Tianning District
				Changzhou  Jiangsu  213000
				CN

98-27-82   (hex)		KORTEK CORPORATION
700000-7FFFFF     (base 16)		KORTEK CORPORATION
				26, Venture-ro24beon-gil, Yeonsu-gu
				Incheon    22011
				KR

98-27-82   (hex)		Dspread Technology (Beijing) Inc.
400000-4FFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

8C-19-2D   (hex)		DataRemote Inc.
200000-2FFFFF     (base 16)		DataRemote Inc.
				18001 Old Cutler Rd. Suite 600
				Palmetto Bay  FL  33157
				US

E8-6C-C7   (hex)		Limited Liability Company M.S.Korp
C00000-CFFFFF     (base 16)		Limited Liability Company M.S.Korp
				Mironovskaya st., 33, bldg.26, floor 4, office 5
				Moscow  Russian Federation  105318
				RU

E8-6C-C7   (hex)		Trapeze Switzerland GmbH
000000-0FFFFF     (base 16)		Trapeze Switzerland GmbH
				Industrieplatz 3.
				Neuhausen am Rheinfall  Schaffhausen  8212
				CH

04-11-19   (hex)		Herrick Tech Labs
700000-7FFFFF     (base 16)		Herrick Tech Labs
				20201 Century Blvd.
				Germantown  MD  20874
				US

E8-6C-C7   (hex)		Lighthouse EIP
800000-8FFFFF     (base 16)		Lighthouse EIP
				21370 Heywood Avenue
				Lakeville  MN  55044
				US

E8-6C-C7   (hex)		Xirgo Technologies LLC
200000-2FFFFF     (base 16)		Xirgo Technologies LLC
				188 Camino Ruiz
				Camarillo  CA  93012
				US

E8-6C-C7   (hex)		Koal Software Co., Ltd
400000-4FFFFF     (base 16)		Koal Software Co., Ltd
				Floor 6, Building 4, Lane 299, Jiangchang West Road, Jing 'an District
				Shanghai  Shanghai  200436
				CN

24-5D-FC   (hex)		Cosmicnode
800000-8FFFFF     (base 16)		Cosmicnode
				Zandstrand
				Eindhoven  North Brabant  5658BJ
				NL

24-5D-FC   (hex)		Suzhou Jiangzhi electronic technology co., Ltd
400000-4FFFFF     (base 16)		Suzhou Jiangzhi electronic technology co., Ltd
				Room 303, Building 2, No.88 Baifu Road, Kunshan Development Zone
				Kunshan  Jiangsu  215300
				CN

60-15-92   (hex)		S Labs sp. z o.o.
000000-0FFFFF     (base 16)		S Labs sp. z o.o.
				Dworska 1a/1u
				Kraków  Lesser Poland  30-314
				PL

60-15-92   (hex)		Annapurna labs
B00000-BFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

60-15-92   (hex)		Zaptec
400000-4FFFFF     (base 16)		Zaptec
				Richard Johnsensgate 4
				Stavanger   Rogaland  N-4021
				NO

0C-5C-B5   (hex)		The Raymond Corporation
500000-5FFFFF     (base 16)		The Raymond Corporation
				22 South Canal St
				Greene  NY  13778
				US

0C-5C-B5   (hex)		ADI
B00000-BFFFFF     (base 16)		ADI
				2 Crest Hollow Lane
				Manorville  NY  11949
				US

1C-A0-EF   (hex)		Shenzhen Liandian Communication Technology Co.LTD
D00000-DFFFFF     (base 16)		Shenzhen Liandian Communication Technology Co.LTD
				1307, building A4, workshop 2, LiLang International Jewelry Industrial Park, 31 Bulan Road, xialilang community, Nanwan street, Longgang District
				Shenzhen  Guangdong  518112
				CN

1C-A0-EF   (hex)		Wisnu and Supak Co.,Ltd.
100000-1FFFFF     (base 16)		Wisnu and Supak Co.,Ltd.
				102/111-112  Mooban  Sinpattanatanee,, Tessabansongkroh  Road.,     Ladyao,  Jatujak,
				Jatujak  Bangkok Metropolis  10900
				TH

88-C9-B3   (hex)		Shenzhen MMUI Co.,Ltd
B00000-BFFFFF     (base 16)		Shenzhen MMUI Co.,Ltd
				Shenzhen MMUI Co.,Ltd
				Shenzhen  Guangdong  518000
				CN

88-C9-B3   (hex)		Robert Bosch JuP1
700000-7FFFFF     (base 16)		Robert Bosch JuP1
				Robert Bosch 1150
				Juarez  Chihuahua  32557
				MX

C8-F5-D6   (hex)		Yarward Electronics  Co., Ltd.
800000-8FFFFF     (base 16)		Yarward Electronics  Co., Ltd.
				9509 Qinglongshan Street
				Zibo  Shandong  255089
				CN

C8-F5-D6   (hex)		Valeo Interior Controls (Shenzhen) Co.,Ltd
100000-1FFFFF     (base 16)		Valeo Interior Controls (Shenzhen) Co.,Ltd
				North Junyi Ind. Park, Huaide Vil., Fuyong Town, Baoan Dist.
				Shenzhen  Guangzhong  518103
				CN

C0-FB-F9   (hex)		Dongmengling
800000-8FFFFF     (base 16)		Dongmengling
				Floor 1, pool-side building, Villa district, Jiuwei Xiange Musical Instrument Co. , Ltd. , Jiuwei community, Hangcheng Street, Bao 'an district
				Shenzhen  Guangdong  518000
				CN

C8-F5-D6   (hex)		Qbic Technology Co., Ltd
200000-2FFFFF     (base 16)		Qbic Technology Co., Ltd
				26F.-12, No.99, Sec. 1, Xintai 5th Rd., Xizhi Dist.,
				New Taipei     22175
				TW

C8-F5-D6   (hex)		EVOTOR LLC
400000-4FFFFF     (base 16)		EVOTOR LLC
				Timura Frunze Str., 24
				Moscow    119021
				RU

C0-FB-F9   (hex)		Dongguan Chuan OptoElectronics Limited
200000-2FFFFF     (base 16)		Dongguan Chuan OptoElectronics Limited
				No.43 Songshui Road,Songmushan Village, Dalang Town
				Dongguan  Guangdong  523795
				CN

C0-FB-F9   (hex)		IVT corporation
600000-6FFFFF     (base 16)		IVT corporation
				5/F, Zhongguancun Fazhan Building, No 12, Shangdi Xinxi Road, Haidian District, Beijing, 100085, P.R. CHINA
				Beijing    100085
				CN

18-74-E2   (hex)		HANGZHOU ZHOUJU ELECTRONIC TECHNOLOGICAL CO.,LTD 
500000-5FFFFF     (base 16)		HANGZHOU ZHOUJU ELECTRONIC TECHNOLOGICAL CO.,LTD 
				Floor 6,A Building, Xianxing Road NO.32,Xianlin Town,Yuhang District
				Hangzhou  Zhejiang  311122
				CN

18-74-E2   (hex)		Shenzhen Jooan Technology  Co., Ltd
B00000-BFFFFF     (base 16)		Shenzhen Jooan Technology  Co., Ltd
				Area B, Floor 101-2, Floor 3, Floor 5 and Floor 6 of area B, Building No. 8, Guixiang Community Plaza Road, Guanlan Street, Longhua District, Shenzhen. 
				Shenzhen  Guangdong  518000
				CN

18-74-E2   (hex)		SHENZHEN AORO COMMUNICATION EQUIPMENT CO., LTD
900000-9FFFFF     (base 16)		SHENZHEN AORO COMMUNICATION EQUIPMENT CO., LTD
				ROOM 302, 3RD FLOOR BUILDING A9, NO.6 YUANCHUANGYUAN,FUHUA ROAD, JUTANG COMMUNITY, FUCHENG STREET, LONGHUA DISTRICT
				SHENZHEN  GUANGDONG  518110
				CN

18-74-E2   (hex)		Shenzhen WITSTECH Co.,Ltd.
200000-2FFFFF     (base 16)		Shenzhen WITSTECH Co.,Ltd.
				5D4, Block CD, Tianji Building, Tian'an Digital City, Futian District, Shenzhen
				Shenzhen  Guangdong?China  518040
				CN

18-74-E2   (hex)		Beijing Jrunion Technology Co., Ltd.
600000-6FFFFF     (base 16)		Beijing Jrunion Technology Co., Ltd.
				Room 01, 2nd Floor, Building 8, Yuquanhuigu, No. 3, Minzhuang Road, Haidian District
				Beijing  Beijing  100195
				CN

FC-CD-2F   (hex)		QCTEK CO.,LTD.
500000-5FFFFF     (base 16)		QCTEK CO.,LTD.
				6F-1., No.496, Bannan Rd., Zhonghe Dist.,
				New Taipei City  New Taipei City  235
				TW

E8-78-29   (hex)		FAIOT Co., LTD
700000-7FFFFF     (base 16)		FAIOT Co., LTD
				Room 1101, Building 23, No.1999 Yishan Road, Minhang District
				Shanghai    200233
				CN

E8-78-29   (hex)		JVISMall CO.,LTD
800000-8FFFFF     (base 16)		JVISMall CO.,LTD
				Rm903, BY B/D, Seogang-ro133, Mapo Gu
				Seoul    04058
				KR

78-13-05   (hex)		Shanghai Siminics Optoelectronic Technology Co., Ltd
D00000-DFFFFF     (base 16)		Shanghai Siminics Optoelectronic Technology Co., Ltd
				Room 9, Building 15, Huatai Center Jinyun Rd
				Shanghai    201803
				CN

E8-78-29   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

78-13-05   (hex)		LEAFF ENGINEERING SRL
200000-2FFFFF     (base 16)		LEAFF ENGINEERING SRL
				Via Pastore 10
				Osimo  AN  60027
				IT

78-13-05   (hex)		Brigates Microelectronics Co., Ltd.
C00000-CFFFFF     (base 16)		Brigates Microelectronics Co., Ltd.
				2007,Building 7, No. 1588 Chuangye Road
				Kunshan  Jiangsu  215300
				CN

98-6D-35   (hex)		Advanced Diagnostics LTD
900000-9FFFFF     (base 16)		Advanced Diagnostics LTD
				Diagnostics House, Eastboro Fields, Hemdale
				Nuneaton  Warwickshire  CV116GL
				GB

A8-5B-36   (hex)		Shenzhen Dandelion Intelligent Cloud Technology Development Co., LTD
300000-3FFFFF     (base 16)		Shenzhen Dandelion Intelligent Cloud Technology Development Co., LTD
				1101, 1102, 1103, 1108A, Building E, Phase II, Galaxy WORLD, Minle Community, Minzhi Street, Longhua District
				Shenzhen  Guangdong  518100
				CN

A8-5B-36   (hex)		ATER Technologies Co Ltd
C00000-CFFFFF     (base 16)		ATER Technologies Co Ltd
				Floor 5,Building 1,HongYe Industry Park,Baoan district
				Shenzhen  Guangdong  518100
				CN

78-13-05   (hex)		microtec Sicherheitstechnik GmbH
300000-3FFFFF     (base 16)		microtec Sicherheitstechnik GmbH
				Auf der Langwies 20
				Hünstetten    65510
				DE

A8-5B-36   (hex)		JUGANU LTD
500000-5FFFFF     (base 16)		JUGANU LTD
				Yehadut Canada St. 1
				Or Yehuda  Israel  6037501
				IL

F0-2A-2B   (hex)		Frigotel SRL
300000-3FFFFF     (base 16)		Frigotel SRL
				Via Trezza, 49
				San Donà di Piave    30027
				IT

A8-5B-36   (hex)		Loomanet Inc.
200000-2FFFFF     (base 16)		Loomanet Inc.
				900 Lafayette St. Suite 704
				Santa Clara  CA  95050
				US

F0-2A-2B   (hex)		Comexio GmbH
C00000-CFFFFF     (base 16)		Comexio GmbH
				Eisenberger Straße 56a
				Kerzenheim    67304
				DE

44-A9-2C   (hex)		Amethystum Storage Technology Co., Ltd
B00000-BFFFFF     (base 16)		Amethystum Storage Technology Co., Ltd
				Guangzhou(Meizhou) Industry Transfer Zone,
				Meizhou  Guangdong  514079
				CN

44-A9-2C   (hex)		RT-Systemtechnik GmbH
800000-8FFFFF     (base 16)		RT-Systemtechnik GmbH
				Jacksonring 4
				Rheine    48429
				DE

44-A9-2C   (hex)		Anhui Zhongxin Electronic Technology Co., Ltd.
200000-2FFFFF     (base 16)		Anhui Zhongxin Electronic Technology Co., Ltd.
				South Head, No.11, Building 2, Huayuan Commercial Building,6km, Changqing Township, Yuhui District, Bengbu City,Anhui Province
				Bengbu  Anhui  233010
				CN

44-A9-2C   (hex)		ZHEJIANG HISING TECHNOLOGY CO.,LTD
000000-0FFFFF     (base 16)		ZHEJIANG HISING TECHNOLOGY CO.,LTD
				Room 201 and 202,Building 5,328 Pingjiang Road,Yuecheng District,Shaoxing
				Shaoxing  Zhejiang  312000
				CN

44-A9-2C   (hex)		Ningbo joyson new energy automotive technology Co.,Ltd
600000-6FFFFF     (base 16)		Ningbo joyson new energy automotive technology Co.,Ltd
				No.1266 Juxian Road, Hi-Tech Park
				Ningbo  Zhejiang  315000
				CN

58-48-49   (hex)		X-speed lnformation Technology Co.,Ltd
200000-2FFFFF     (base 16)		X-speed lnformation Technology Co.,Ltd
				th Floor,Building 2,Xinyu Electronic Industrial Park,No.69, Zhaishan,Houshan Village, High-tech Zone,Fuzhou,Fujian ,China
				Fuzhou    350000
				CN

64-33-B5   (hex)		Adesso, Inc
200000-2FFFFF     (base 16)		Adesso, Inc
				20659 Valley Boulevard
				Walnut  CA  91789
				US

28-36-13   (hex)		shenzhen technology limited
700000-7FFFFF     (base 16)		shenzhen technology limited
				903,No. 1 Shifeng Building, Xinzhuang Community Villa Road, Matian Street, Guangming District, Shenzhen City
				Shenzhen  Guangdong  518000
				CN

04-71-4B   (hex)		uAvionix Corporation
100000-1FFFFF     (base 16)		uAvionix Corporation
				300 Pine Needle Lane
				Bigfork  MT  59911
				US

64-33-B5   (hex)		Geksacon
C00000-CFFFFF     (base 16)		Geksacon
				Revolutionary Street 78
				Ufa  Republic of Bashkortostan  450005
				RU

78-5E-E8   (hex)		Guangdong COROS Sports Technology Co., Ltd
600000-6FFFFF     (base 16)		Guangdong COROS Sports Technology Co., Ltd
				ROOM 601 ROOM 701,BLD.2,NO.2,SCIENCE AND TECHNOLOGY 9 RD,SONGSHAN LAKE HI-TECH ZONE
				Dongguan  Guangdong  523808
				CN

38-A8-CD   (hex)		OUTFORM
E00000-EFFFFF     (base 16)		OUTFORM
				82 NE 26th Street Suite #103
				Miami  FL  33137
				US

7C-83-34   (hex)		PRO BRAND TECHNOLOGY (TW)
500000-5FFFFF     (base 16)		PRO BRAND TECHNOLOGY (TW)
				14F-6,1071 Chung Cheng Road
				Taoyuan     330
				TW

1C-AE-3E   (hex)		Annapurna labs
600000-6FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

1C-AE-3E   (hex)		FORME
D00000-DFFFFF     (base 16)		FORME
				204 west spear street suite 3697
				carson city  NV  89703
				US

1C-AE-3E   (hex)		Beijing SuperCloud Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Beijing SuperCloud Technology Co., Ltd.
				yizhuang 
				beijing  beijing  100176
				CN

98-6E-E8   (hex)		Fujitsu component limited
400000-4FFFFF     (base 16)		Fujitsu component limited
				SHINAGAWA SEASIDE PARK TOWER, 12-4, Higashi-shinagawa
				4-chome, Shinagawa-ku,  Tokyo  140-8586
				JP

78-13-05   (hex)		E-Stone Electronics Co., Ltd
700000-7FFFFF     (base 16)		E-Stone Electronics Co., Ltd
				Room 0355, Unit 109, No. 62, Chengyi North Street, Software Park Phase III, Xiamen City
				Fujian  Fujian  361000
				CN

98-6E-E8   (hex)		Sercomm Corporation.
C00000-CFFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

98-80-BB   (hex)		Shenzhen Ginto E-commerce CO.,LTD
400000-4FFFFF     (base 16)		Shenzhen Ginto E-commerce CO.,LTD
				Room 1308-1309, Building B, Huihai Square, Chuangye Road, Longhua District, Shenzhen
				Shenzhen  Guangdong  570100
				CN

78-72-64   (hex)		QT systems ab
D00000-DFFFFF     (base 16)		QT systems ab
				Finnbacksgatan 11
				Lycksele  Västerbotten  921 32
				SE

78-72-64   (hex)		SHENZHEN FANGZHICHENG TECHNOLOGY CO., LTD.
900000-9FFFFF     (base 16)		SHENZHEN FANGZHICHENG TECHNOLOGY CO., LTD.
				SHENZHEN FANGZHICHENG TECHNOLOGY CO., LTD.
				SHENZHEN  GUANGDONG  518000
				CN

78-72-64   (hex)		Gsou Technology(Shenzhen)Co.,Ltd
800000-8FFFFF     (base 16)		Gsou Technology(Shenzhen)Co.,Ltd
				18B.Block B,First World Plaza,No.7002 West HongLi road,Futian,
				ShenZhen    518000
				CN

98-FC-84   (hex)		ZeXin (Shanghai) Information Technologies Co.,Ltd
300000-3FFFFF     (base 16)		ZeXin (Shanghai) Information Technologies Co.,Ltd
				Room 205E Building 5#,545 Hulan Road,Baoshan District,Shanghai City
				Shanghai    200000
				CN

3C-39-E7   (hex)		HomeWizard B.V.
200000-2FFFFF     (base 16)		HomeWizard B.V.
				Keyserswey 79
				Noordwijk  Zuid-Holland  2201CX
				NL

F4-70-0C   (hex)		Annapurna labs
900000-9FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

F4-70-0C   (hex)		Jinan USR IOT Technology Limited
600000-6FFFFF     (base 16)		Jinan USR IOT Technology Limited
				Floor F1 & Part of Floor F2, Building No. 9,Diya shuang chuang Industrial Zone, No.2566,Century Main Road,Gaoxin District Jinan,Shandong China
				Shandong  Jinan  250014
				CN

F4-70-0C   (hex)		Beijing ASU Tech Co., Ltd.
200000-2FFFFF     (base 16)		Beijing ASU Tech Co., Ltd.
				11th Floor Block A, Beijing Normal University Science & Technology Mansion, No.12 Xueyuan South Road,Haidian District,Beijing, China
				Beijing    100088
				CN

F4-70-0C   (hex)		Freeus LLC
D00000-DFFFFF     (base 16)		Freeus LLC
				1069 Stewart Drive, Suites 3-6
				Ogden  UT  84404
				US

F4-A4-54   (hex)		Denshijiki Industry Co.,Ltd
500000-5FFFFF     (base 16)		Denshijiki Industry Co.,Ltd
				5-6-20 Ukima
				Kita-ku  Tokyo-to  115-0051
				JP

F4-A4-54   (hex)		Earshots
400000-4FFFFF     (base 16)		Earshots
				Aviation Way
				Palmerston North  Manawatu  4410
				NZ

18-45-B3   (hex)		Pfannenberg GmbH
100000-1FFFFF     (base 16)		Pfannenberg GmbH
				Werner-Witt-Straße 1
				Hamburg  Hamburg  21035
				DE

18-45-B3   (hex)		leetop tech co.,ltd
000000-0FFFFF     (base 16)		leetop tech co.,ltd
				2203 Changhong Technology Building, Science and Technology Park
				shenzhen city  GD province  518053
				CN

F4-A4-54   (hex)		Annapurna labs
A00000-AFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

18-45-B3   (hex)		Haier cloud Health Technology (Qingdao) Co., Ltd
200000-2FFFFF     (base 16)		Haier cloud Health Technology (Qingdao) Co., Ltd
				Room c1-201, No. 127, huizhiqiao Road, high tech Zone
				Qingdao  Shandong  266114
				CN

18-45-B3   (hex)		ShenZhen Topband Co.,Ltd
800000-8FFFFF     (base 16)		ShenZhen Topband Co.,Ltd
				Topband Industrial Park, Shiyan Town, Bao'anDistrict,Shenzhen
				Shenzhen    518000
				CN

94-C9-B7   (hex)		Annapurna labs
200000-2FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

50-A0-30   (hex)		Jiangsu Jinshi Legend Technology Co.,Ltd
500000-5FFFFF     (base 16)		Jiangsu Jinshi Legend Technology Co.,Ltd
				North-2, floor 13, building A3, No. 8, Bailongjiang East Street, Xincheng Science Park, Jianye District, Nanjing
				Nanjing    210005
				CN

94-C9-B7   (hex)		C-Mer Rainsoptics Limited
100000-1FFFFF     (base 16)		C-Mer Rainsoptics Limited
				Room 607, 6/F, 17W of Hong Kong Science Park, No.17 Science Park West Avenue 
				Shatin  Hong Kong  000000
				HK

50-A0-30   (hex)		SHANGHAI ZXELINK Co.,Ltd
B00000-BFFFFF     (base 16)		SHANGHAI ZXELINK Co.,Ltd
				No.889 Bibo Road, Zhangjiang Hi-Tech Park
				Shanghai  Shanghai Province  200000
				CN

7C-BA-CC   (hex)		Fortem Technologies, Inc.
500000-5FFFFF     (base 16)		Fortem Technologies, Inc.
				1064 S NORTH COUNTY BLVD STE 600
				PLEASANT GROVE  UT  84062-3446
				US

50-DE-19   (hex)		Clear Flow by Antiference
100000-1FFFFF     (base 16)		Clear Flow by Antiference
				Unit 2 Common Lane Fradley Park
				Lichfield  Staffordshire  WS13 8NQ
				GB

50-A0-30   (hex)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
D00000-DFFFFF     (base 16)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
				NO.8 Tangzhuang Road,Suzhou Industrial Park,Su ZhouCity,JiangSu Province,China
				Suzhou    215021
				CN

50-A0-30   (hex)		HANKOOK CTEC CO,. LTD.
E00000-EFFFFF     (base 16)		HANKOOK CTEC CO,. LTD.
				404 Hallasigmavalley, 53, Gasandigital 2-ro Geumcheongu
				Seoul    08588
				KR

18-D7-93   (hex)		zhejiang Anhong technology co.,ltd
A00000-AFFFFF     (base 16)		zhejiang Anhong technology co.,ltd
				Floor 3, Building 2, No.6, Changtai Street, Changkou Town, Fuyang District
				hangzhou  zhejiang  311400
				CN

18-D7-93   (hex)		Kraken Technologies Ltd
D00000-DFFFFF     (base 16)		Kraken Technologies Ltd
				33 Holborn
				London    EC1N 2HT
				GB

18-D7-93   (hex)		Clarity Medical Pvt Ltd
900000-9FFFFF     (base 16)		Clarity Medical Pvt Ltd
				PLOT No. 1687A, JLPL  INDUSTRIAL AREA, SECTOR 82, MOHALI
				MOHALI  Punjab  140306
				IN

04-EE-E8   (hex)		SHENZHEN TOPWELL TECHNOLOGY CO., LTD.
D00000-DFFFFF     (base 16)		SHENZHEN TOPWELL TECHNOLOGY CO., LTD.
				15/F, Building A1, Qiaode Science & Technology Park, No.7 Road, Hi-Tech Industry Park ,Guangming new district
				Shenzhen  Guang Dong   518000
				CN

04-EE-E8   (hex)		daishin
C00000-CFFFFF     (base 16)		daishin
				9828-15 Kataokaimaizumi
				Shiojiri-shi  Nagano-ken  3990711
				JP

18-D7-93   (hex)		Annapurna labs
100000-1FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

DC-36-43   (hex)		Fresenius Medical Care R&D (Shanghai) Co.,Ltd.
400000-4FFFFF     (base 16)		Fresenius Medical Care R&D (Shanghai) Co.,Ltd.
				Building 15, No. 1036 Tianlin road, Shanghai
				shanghai    200233
				CN

08-26-AE   (hex)		ZaiNar
200000-2FFFFF     (base 16)		ZaiNar
				2 Davis Drive, Unit 1
				Belmont  CA  94002
				US

98-8F-E0   (hex)		Dongguan Synst Electronics Co., LTD.
B00000-BFFFFF     (base 16)		Dongguan Synst Electronics Co., LTD.
				No. 20, Fudong Road, Houjie Town
				Dongguan  Guangdong  523966
				CN

98-8F-E0   (hex)		vhf elektronik GmbH
200000-2FFFFF     (base 16)		vhf elektronik GmbH
				Melli-Beese-Str. 24
				Fuerth  Bavaria  90768
				DE

98-8F-E0   (hex)		Shenzhen Micro&Nano Perception Computing Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen Micro&Nano Perception Computing Technology Co.,Ltd
				shenzhenshifutianquzhongkanglu136haoxinyidaichanyeyuan4dong6lou
				shenzhen  guangdong  518000
				CN

08-26-AE   (hex)		Shenzhen Hai yingZhilian Industrial Co., Ltd.
300000-3FFFFF     (base 16)		Shenzhen Hai yingZhilian Industrial Co., Ltd.
				2-5/F? #8FactoryBld?Yu'an Factory Area ?LongchengIndustryPark?Gao feng Community ?Dalang Street ?
				Shenzhen  Guangdong   518110
				CN

98-8F-E0   (hex)		Empowerment Technologies Inc.
300000-3FFFFF     (base 16)		Empowerment Technologies Inc.
				590 York Rd., Unit 2
				Niagara-on-the-Lake  Ontario  L0S 1J0
				CA

94-05-BB   (hex)		closip Inc.
700000-7FFFFF     (base 16)		closip Inc.
				3F, Canal Square Shibaura, 3-14-18 Shibaura
				Tokyo  Minato  108-0023
				JP

0C-86-29   (hex)		HONGKONG SAINT TECH INDUSTRIAL LIMITED
900000-9FFFFF     (base 16)		HONGKONG SAINT TECH INDUSTRIAL LIMITED
				RM 1904A 19/F LUCKY COMMERCIAL CENTRE NO.103 DES VOEUX ROAD WEST HK
				HONGKONG    999077
				CN

0C-86-29   (hex)		BEIJING BEIBIANZHIDA TECHNOLOGY CO.,LTD
D00000-DFFFFF     (base 16)		BEIJING BEIBIANZHIDA TECHNOLOGY CO.,LTD
				27 Shucun West Road, Haidian District,
				Beijing    100089
				CN

0C-86-29   (hex)		Shenzhen protostellar technology Co., Ltd
500000-5FFFFF     (base 16)		Shenzhen protostellar technology Co., Ltd
				 4/F, #16, DaKan Yangmen industrial park, XiLi town,  Nanshan district
				ShenZhen  GuangDong  518055
				CN

0C-86-29   (hex)		Akribis Systems
B00000-BFFFFF     (base 16)		Akribis Systems
				Block 5012 Techplace II, #01-05 Ang Mo Kio Avenue 5
				Singapore  Singapore  569876
				SG

6C-93-08   (hex)		Shenzhen C & D Electronics Co., Ltd.
500000-5FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

6C-93-08   (hex)		Braums
000000-0FFFFF     (base 16)		Braums
				Unit M 10-16 South st
				Rydalmere   NSW  2116
				AU

6C-93-08   (hex)		WATERFORD CONSULTANTS LLC
100000-1FFFFF     (base 16)		WATERFORD CONSULTANTS LLC
				7430 NEW TECHNOLOGY WAY, Suite 150
				FREDERICK    21703
				US

50-FF-99   (hex)		COYOTE SYSTEM
100000-1FFFFF     (base 16)		COYOTE SYSTEM
				24 quai Gallieni
				Suresnes    92150
				FR

30-43-D7   (hex)		Apollo Infoways Private Limited
200000-2FFFFF     (base 16)		Apollo Infoways Private Limited
				G-149, Sector-63
				Noida  Uttar Pradesh  201301
				IN

30-43-D7   (hex)		Luxshare Electronic Technology (Kunshan) LTD
300000-3FFFFF     (base 16)		Luxshare Electronic Technology (Kunshan) LTD
				No.158,Jinchang Road,Jinxi Town,Kunshan City,Jiangsu Province,215324, China
				Kunshan  Jiangsu  215324
				CN

38-1F-26   (hex)		Avon Protection
800000-8FFFFF     (base 16)		Avon Protection
				503 8th Street
				Cadillac  MI  49601
				US

30-43-D7   (hex)		DIGICITI Technology Co.,Ltd
700000-7FFFFF     (base 16)		DIGICITI Technology Co.,Ltd
				Room 3502,Building 1,Huide Building,North Station Community,Minzhi Street,Longhua District
				Shenzhen  Guangdong  518000
				CN

38-1F-26   (hex)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
100000-1FFFFF     (base 16)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
				NO.8 Tangzhuang Road,Suzhou Industrial Park,Su ZhouCity,JiangSu Province,China
				Suzhou    215021
				CN

38-1F-26   (hex)		SMS Evoko Group AB
900000-9FFFFF     (base 16)		SMS Evoko Group AB
				Hastholmsvagen 32
				Nacka    13130
				SE

18-A5-9C   (hex)		CAL-COMP INDUSTRIA E COMERCIO DE ELETRONICOS E INFORMATICA LTDA
B00000-BFFFFF     (base 16)		CAL-COMP INDUSTRIA E COMERCIO DE ELETRONICOS E INFORMATICA LTDA
				AVENIDA TORQUATO TAPAJOS, 7503 TARUMA GALPAO 2 - CNPJ: 07.200.194/0003-80
				MANAUS  AMAZONAS  69041-025
				BR

18-A5-9C   (hex)		Thermia AB
500000-5FFFFF     (base 16)		Thermia AB
				Snickaregatan 1
				Arvika    67134
				SE

18-A5-9C   (hex)		BlueEyes Technology
C00000-CFFFFF     (base 16)		BlueEyes Technology
				7F-3, No.200, Sec. 4, Wenxin Rd.,
				Taichung City  Taiwan  40462
				TW

9C-43-1E   (hex)		SHURE INCORPORATED
E00000-EFFFFF     (base 16)		SHURE INCORPORATED
				2552 White Road, Suite A
				Irvine  CA  92614
				US

1C-59-74   (hex)		Globe Tracker ApS
E00000-EFFFFF     (base 16)		Globe Tracker ApS
				Strandgade 91
				kobenhavn  State / Province*  1401
				DK

C4-A1-0E   (hex)		HYOSUNG HEAVY INDUSTRIES
000000-0FFFFF     (base 16)		HYOSUNG HEAVY INDUSTRIES
				119, Mapo-daero (Gongdeok-dong), Mapo-gu
				Seoul    04144
				KR

C4-A1-0E   (hex)		Consolinno Energy GmbH
300000-3FFFFF     (base 16)		Consolinno Energy GmbH
				Franz-Mayer-Straße 1
				Regensburg  Bayern  93053
				DE

C4-A1-0E   (hex)		Connectlab SRL
D00000-DFFFFF     (base 16)		Connectlab SRL
				via donatello 30
				Milano  Milano  20131 - Milano
				IT

C4-A1-0E   (hex)		BARTEC PIXAVI AS
100000-1FFFFF     (base 16)		BARTEC PIXAVI AS
				Vestre Svanholmen 24
				SANDNES  Rogaland  4313
				NO

C4-A1-0E   (hex)		Ayla Networks (Shenzhen) Co., Ltd.
800000-8FFFFF     (base 16)		Ayla Networks (Shenzhen) Co., Ltd.
				Room 1501, Building B, Innovation Building, No.198 Daxin Road, Majialong Community ,Nantou Street,Nanshan District, 
				Shenzhen    518000
				CN

70-50-E7   (hex)		Shenzhen Dangs Science and Technology CO.,Ltd.
800000-8FFFFF     (base 16)		Shenzhen Dangs Science and Technology CO.,Ltd.
				9th Floor of GDC Building, Gaoxin Middle 3rd St.,Nanshan District
				Shenzhen  GuangDong  518063
				CN

70-50-E7   (hex)		KFBIO (KONFOONG BIOINFORMATION TECH CO.,LTD)
E00000-EFFFFF     (base 16)		KFBIO (KONFOONG BIOINFORMATION TECH CO.,LTD)
				3F,No.4Building,Yuyao Technology Innovation Center
				Ningbo  ZheJiang Province, P.R.C.  315400
				CN

80-7B-85   (hex)		SCALA Digital Technology(Ningbo) CO, LTD
C00000-CFFFFF     (base 16)		SCALA Digital Technology(Ningbo) CO, LTD
				7 Hong Da Road, Hong Tang Industrial Park Zone A
				Ningbo  Zhejiang  315040
				CN

80-02-F4   (hex)		Baicells Technologies Co., Ltd
B00000-BFFFFF     (base 16)		Baicells Technologies Co., Ltd
				10-11F,AL, No.1 Zhongguancun, Haidian
				Beijing  Beijing  100094
				CN

80-02-F4   (hex)		BK Networks Co,. Ltd.
000000-0FFFFF     (base 16)		BK Networks Co,. Ltd.
				330 Suin-ro, Gwonseon-gu
				Suwon-si  Gyeonggi-do  16371
				KR

8C-51-09   (hex)		Heliox Automotive B.V.
500000-5FFFFF     (base 16)		Heliox Automotive B.V.
				De Waal 24
				Best    5684 PH
				NL

8C-51-09   (hex)		Amzetta Technologies, LLC
100000-1FFFFF     (base 16)		Amzetta Technologies, LLC
				5555 Oakbrook Pkwy, Suite 280
				Norcross  GA  30093
				US

FC-61-79   (hex)		Qisda Corporation
500000-5FFFFF     (base 16)		Qisda Corporation
				No. 157, Shanying Rd., Gueishan Dist., Taoyuan City 33341, Taiwan
				Taoyuan    33341
				TW

0C-7F-ED   (hex)		Guangdong Tianshu New Energy Technology Co., Ltd
000000-0FFFFF     (base 16)		Guangdong Tianshu New Energy Technology Co., Ltd
				No.8 Huishang Road, Infore Enviro Industrial Park, Jiangcun Village, Leliu Street, Shunde District, 
				Foshan    528000
				CN

0C-7F-ED   (hex)		Annapurna labs
A00000-AFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

4C-4B-F9   (hex)		Shenzhen dingsheng technology co., LTD
400000-4FFFFF     (base 16)		Shenzhen dingsheng technology co., LTD
				Floor 3, building 5, kaijeda industrial zone, no.97, huaxing road, langkou community, dalang street, longhua district
				Shenzhen  Guangdong  518000
				CN

4C-4B-F9   (hex)		Connected IO
C00000-CFFFFF     (base 16)		Connected IO
				8304 Esters Boulevard, Suite 850
				Irving  TX  75063
				US

4C-4B-F9   (hex)		Zivid AS
800000-8FFFFF     (base 16)		Zivid AS
				Gjerdrums vei 10A
				Oslo    0484
				NO

20-85-93   (hex)		Hemina Spa
000000-0FFFFF     (base 16)		Hemina Spa
				Hemina SPA, via Piemonte 2
				Montangnana  Padova  35044
				IT

20-85-93   (hex)		Regloplas AG
C00000-CFFFFF     (base 16)		Regloplas AG
				Flurhofstrasse 158c
				St. Gallen    9006
				CH

4C-4B-F9   (hex)		Jiangsu acrel Co., Ltd.
100000-1FFFFF     (base 16)		Jiangsu acrel Co., Ltd.
				No. 5, Dongmeng Road, Nanzha Street
				Jiangyin City   Jiangsu Province  214400
				CN

4C-4B-F9   (hex)		GLONEXS
700000-7FFFFF     (base 16)		GLONEXS
				3F, 19-14, Doyak-ro 252beon-gil
				Bucheon  Gyeonggi-do  14531
				KR

4C-4B-F9   (hex)		Remedee Labs
500000-5FFFFF     (base 16)		Remedee Labs
				35 chemin du vieux chene
				Meylan  France  38240
				FR

20-85-93   (hex)		Dynaudio
E00000-EFFFFF     (base 16)		Dynaudio
				Sverigesvej 15
				Skanderborg    DK-8660
				DK

84-39-BE   (hex)		Cheng Du virtual world Technology Limited.
200000-2FFFFF     (base 16)		Cheng Du virtual world Technology Limited.
				7F, Fang Da building, Ave 12 High-tech Industrial Park, Nanshan Dist
				Shenzhen  Guangdong  518057
				CN

24-15-10   (hex)		Satellite Link Technology CO.,LTD
E00000-EFFFFF     (base 16)		Satellite Link Technology CO.,LTD
				1305 ,SED science and technology Building,No.1 science and technology road,Nanshan District
				Shenzhen  Guangdong  518057
				CN

20-85-93   (hex)		Kloudspot Inc
400000-4FFFFF     (base 16)		Kloudspot Inc
				1285 Oakmead Parkway
				Sunnyvale    94085
				US

24-15-10   (hex)		Shenzhen Xtooltech Co., Ltd
C00000-CFFFFF     (base 16)		Shenzhen Xtooltech Co., Ltd
				10574 Acacia St, Suite D4
				Rancho Cucamonga  CA  91730
				US

24-15-10   (hex)		Safetrust Inc
000000-0FFFFF     (base 16)		Safetrust Inc
				8112 Mill Creek Rd
				Fremont  CA  94539
				US

20-85-93   (hex)		Networking Services Corp
100000-1FFFFF     (base 16)		Networking Services Corp
				Bella Vista, Obarrio, Edificio Magna Corp, Mezanine
				Panama  Panama  33131
				PA

24-15-10   (hex)		SMaBiT GmbH
100000-1FFFFF     (base 16)		SMaBiT GmbH
				Friedrichstrasse 95
				Berlin    10117
				DE

98-06-37   (hex)		HwaCom Systems Inc.
C00000-CFFFFF     (base 16)		HwaCom Systems Inc.
				11Fl., No.108, Sec. 1, Hsin-Tai-Wu Rd., Hsi-Chih District
				New Taipei  New Taipei  221
				TW

54-9A-11   (hex)		Private
F00000-FFFFFF     (base 16)		Private

24-15-10   (hex)		Unitronux(Shenzhen) Intelligence Technology Co.,Ltd
A00000-AFFFFF     (base 16)		Unitronux(Shenzhen) Intelligence Technology Co.,Ltd
				7th floor,Building 7,ZhongYunTai industy Park, Tangtou 1st Road,Bao'an District.
				Shenzhen  Guangdong  518108
				CN

98-06-37   (hex)		Petersime
B00000-BFFFFF     (base 16)		Petersime
				Centrumstraat 125
				Zulte    9870
				BE

98-06-37   (hex)		VR Technology(Shenzhen) Limited
D00000-DFFFFF     (base 16)		VR Technology(Shenzhen) Limited
				Room 201,Huiheng Building,No.12,Gaoxin South 7th Road,Yuehai Steet,Nanshan District
				Shenzhen  Guangdong  518000
				CN

98-06-37   (hex)		SAMWONTECH
700000-7FFFFF     (base 16)		SAMWONTECH
				YAKDAE-DONG, BUCHEON TECHNO-PARK
				BUCHEON-CITY  KYUNGGI-DO  14502
				KR

98-06-37   (hex)		Hangzhou Sanxin Network Technology Co.,Ltd
300000-3FFFFF     (base 16)		Hangzhou Sanxin Network Technology Co.,Ltd
				No. 195, Wen Er Road, Xihu District, Xinyuan 11-18F
				Hangzhou  Zhejiang  310012
				CN

98-06-37   (hex)		NAB co,.LTD
900000-9FFFFF     (base 16)		NAB co,.LTD
				3-62-30 utukushigaoka aoba-ku
				Yokohama-city  KANAGAWA-KEN  2250002
				JP

74-19-F8   (hex)		Private
F00000-FFFFFF     (base 16)		Private

E4-95-6E   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D0-5F-64   (hex)		Shanghai Luying International Trade Co.,Ltd
900000-9FFFFF     (base 16)		Shanghai Luying International Trade Co.,Ltd
				Room 1009 Block 12 No.858 South Huanzhen Road Baoshan District Shanghai City
				Shanghai     200442
				CN

D0-5F-64   (hex)		Atoll Solutions Private Limited
500000-5FFFFF     (base 16)		Atoll Solutions Private Limited
				#229, 2nd Floor, 2A Main, 5th Cross, New Thippasandra
				Bangalore  Karnataka  560075
				IN

D0-5F-64   (hex)		SHANGHAI ZHONGMI COMMUNICATION TECHNOLOGY CO.,LTD
200000-2FFFFF     (base 16)		SHANGHAI ZHONGMI COMMUNICATION TECHNOLOGY CO.,LTD
				RM510,418GuipingRoad.Caohejing Hi-TECH-PARK
				SHANGHAI    200233
				CN

D0-5F-64   (hex)		HUAQIN TELECOM HONG KONG LTD
300000-3FFFFF     (base 16)		HUAQIN TELECOM HONG KONG LTD
				Unit 510,5/F, Lincoln Center,20 Yip Fung Street,Fanling
				N.T.    999077
				HK

2C-27-9E   (hex)		Private
300000-3FFFFF     (base 16)		Private

44-D5-F2   (hex)		CETC Avionics.L td
800000-8FFFFF     (base 16)		CETC Avionics.L td
				No. 9, baichuan road, high-tech district
				Chengdu  Sichuan  611731
				CN

44-D5-F2   (hex)		VURO LLC
300000-3FFFFF     (base 16)		VURO LLC
				1441 Broadway, Suite 5011
				New York  NY  10018
				US

D0-5F-64   (hex)		North American Blue Tiger Company, LLC
B00000-BFFFFF     (base 16)		North American Blue Tiger Company, LLC
				3727 Greenbriar Dr.  Suite 119
				Stafford  TX  77477
				US

44-D5-F2   (hex)		SIMPLERED TECHNOLOGY LTD.
100000-1FFFFF     (base 16)		SIMPLERED TECHNOLOGY LTD.
				8F., No.23, Ln. 155, Sec. 3, Beishen Rd., Shenkeng Dist.
				New Taipei City    222
				TW

44-D5-F2   (hex)		APPOTRONICS CO., LTD
400000-4FFFFF     (base 16)		APPOTRONICS CO., LTD
				4th Floor,SZICC,NO.1089,Chaguang Road,Nanshan District, Shenzhen, China
				Shenzhen  Guangdong  518000
				CN

44-D5-F2   (hex)		TIBA Research & Development (1986) LTD
000000-0FFFFF     (base 16)		TIBA Research & Development (1986) LTD
				17 Ha'Mefalsim St. Kiryat Arye
				Petach Tikva  Israel  4951251
				IL

FC-A4-7A   (hex)		Broadcom Inc.
000000-0FFFFF     (base 16)		Broadcom Inc.
				Wernerwerkstr. 2
				Regensburg  Bavaria  93055
				DE

FC-A4-7A   (hex)		Shenzhen Nokelock Technology Co, Ltd.
B00000-BFFFFF     (base 16)		Shenzhen Nokelock Technology Co, Ltd.
				9th Floor, B Block, Fuhua Technology Building, No 9116 Beihuan  Road, Xili Street, Nanshan District,
				Shenzhen    518057
				CN

FC-A4-7A   (hex)		Token
600000-6FFFFF     (base 16)		Token
				4545 East River Road, Suite 310
				Henrietta  NY  14586
				US

2C-16-BD   (hex)		Sunit Oy
400000-4FFFFF     (base 16)		Sunit Oy
				Taitoraitti 1
				Kajaani    87400
				FI

8C-59-3C   (hex)		Scharfe-Sicht GmbH
B00000-BFFFFF     (base 16)		Scharfe-Sicht GmbH
				Huttropstraße 60
				Essen   Nordrhein-Westfalen  45138 
				DE

8C-59-3C   (hex)		ecom instruments GmbH
A00000-AFFFFF     (base 16)		ecom instruments GmbH
				Industriestr.2
				Assamstadt  Baden-Württemberg  97959
				DE

8C-59-3C   (hex)		Shenzhen Tian-Power Technology Co.,Ltd.
E00000-EFFFFF     (base 16)		Shenzhen Tian-Power Technology Co.,Ltd.
				Guangming New District Gongming Office Yulu Community No. 6 Industrial Zone Building 26
				Shenzhen  Guangdong  518000
				CN

B4-A2-EB   (hex)		QKM Technology(Dongguan)Co.,Ltd
000000-0FFFFF     (base 16)		QKM Technology(Dongguan)Co.,Ltd
				2F,Block A Building 17,NO. 1,Headquarter,No.4,Xinzhu Road,SSL National Hi-tech Industrial Development Zone
				Dongguan  Guangdong  523808
				CN

B4-A2-EB   (hex)		Kona I
700000-7FFFFF     (base 16)		Kona I
				4F EXCON Venture-Tower, 3, Eunhaeng-ro, Youngdeungpo-gu,
				Seoul    07237
				KR

2C-D1-41   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D0-C8-57   (hex)		Eco Mobile 
700000-7FFFFF     (base 16)		Eco Mobile 
				Samoborska cesta 330
				Zagreb  Zagreb  10090
				HR

D0-C8-57   (hex)		Mobicon
300000-3FFFFF     (base 16)		Mobicon
				#406, 97, Jungbu-daero 448beon-gil, Yeongtong-gu
				Suwon-si  Gyeonggi-do  16521
				KR

60-95-CE   (hex)		Synamedia
C00000-CFFFFF     (base 16)		Synamedia
				Luipaardstraat 12
				Kortrijk  West-Vlaanderen  8500
				BE

1C-82-59   (hex)		ESTec Corporation
A00000-AFFFFF     (base 16)		ESTec Corporation
				22, Yusangongdan 9-gil
				Yangsan  Gyeongsangnam-do  50592
				KR

1C-82-59   (hex)		CGI IT UK LIMITED
600000-6FFFFF     (base 16)		CGI IT UK LIMITED
				20 Fenchurch Street, 14th Floor
				London    EC3M 3BY
				GB

60-95-CE   (hex)		Untangle, Inc.
400000-4FFFFF     (base 16)		Untangle, Inc.
				100 W. San Fernando St., Ste. 565
				San Jose  CA  95113
				US

B0-FD-0B   (hex)		IDspire Corporation Ltd.
100000-1FFFFF     (base 16)		IDspire Corporation Ltd.
				9F, No. 266, Sec. 1, Wenhua Rd., Banqiao Dist.
				New Taipei City    22041
				TW

84-8B-CD   (hex)		SouXin Corporate
000000-0FFFFF     (base 16)		SouXin Corporate
				33 Jingyou Road
				Nanjing  Jiangsu  211100
				CN

B0-FD-0B   (hex)		Shenzhen FEIBIT Electronic Technology Co.,LTD
E00000-EFFFFF     (base 16)		Shenzhen FEIBIT Electronic Technology Co.,LTD
				5th floor,Bld. A1, Lilang Software Park
				Shenzhen    518112
				CN

C8-2C-2B   (hex)		Smart Wires Inc
C00000-CFFFFF     (base 16)		Smart Wires Inc
				3292 Whipple Road
				Union City   CA  94587
				US

C8-2C-2B   (hex)		Verifone Systems (China),lnc.
800000-8FFFFF     (base 16)		Verifone Systems (China),lnc.
				2nd Floor,No.39,Region C, Tongpan Road,Gulou District
				fuzhou  fujian  350004
				CN

C8-2C-2B   (hex)		Fränkische Rohrwerke Gebr. Kirchner GmbH & Co. KG
E00000-EFFFFF     (base 16)		Fränkische Rohrwerke Gebr. Kirchner GmbH & Co. KG
				Hellinger Str. 1
				Königsberg/Bayern    97486
				DE

C8-2C-2B   (hex)		Repp Health
200000-2FFFFF     (base 16)		Repp Health
				1919 14th Street , Suite 700
				Boulder  CO  80302
				US

E4-1E-0A   (hex)		FireAngel Safety Technology Ltd
A00000-AFFFFF     (base 16)		FireAngel Safety Technology Ltd
				Sir William Lyons Road, Vanguard Centre
				Coventry  Warwickshire  CV4 7EZ
				GB

E4-1E-0A   (hex)		Avast Software s.r.o.
300000-3FFFFF     (base 16)		Avast Software s.r.o.
				Pikrtova 1737/1a
				Prague 4    14000
				CZ

C8-63-14   (hex)		Taylor Dynamometer
E00000-EFFFFF     (base 16)		Taylor Dynamometer
				3602 W Wheelhouse Rd.
				Milwaukee  WI  53208
				US

C8-63-14   (hex)		Western Reserve Controls, Inc.
000000-0FFFFF     (base 16)		Western Reserve Controls, Inc.
				1485 Exeter Dr.
				Akron  OH  44306
				US

34-E1-D1   (hex)		Genius Pros
700000-7FFFFF     (base 16)		Genius Pros
				Floor 13,  Building B, NO. 859 West Shixiang Road, Xihu District, Hangzhou City
				Hangzhou    310012
				CN

34-E1-D1   (hex)		ASA Innovation & Technology Ltd.
400000-4FFFFF     (base 16)		ASA Innovation & Technology Ltd.
				Room 506, 5/F, Enterprise Place, No. 5 Science Park West Ave., Hong Kong Science Park
				Shatin  NT  00000
				HK

34-E1-D1   (hex)		Ningbo Hua Gao Mdt Info Tech Ltd
600000-6FFFFF     (base 16)		Ningbo Hua Gao Mdt Info Tech Ltd
				NO.655,Xueshi Road, Yinzhou District, Ningbo, Zhejiang,China
				Ningbo  Zhejiang  315100
				CN

34-E1-D1   (hex)		Rinco Ultrasonics AG
300000-3FFFFF     (base 16)		Rinco Ultrasonics AG
				Industriestrasse 4
				Romanshorn  Thurgau  8590
				CH

C8-63-14   (hex)		Meyer Electronics Limited
500000-5FFFFF     (base 16)		Meyer Electronics Limited
				382 Kwun Tong Road
				Hong Kong    0000
				HK

FC-D2-B6   (hex)		Silicon (Shenzhen) Electronic Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Silicon (Shenzhen) Electronic Technology Co.,Ltd.
				5F, Block A，No. 9 Yuexing 3rd Road, Yuehai Subdistrict Office, Nanshan District
				Shenzhen  Guangdong  518000
				CN

FC-D2-B6   (hex)		Univer S.p.A.
E00000-EFFFFF     (base 16)		Univer S.p.A.
				Via Eraclito 31
				Milan    20128
				IT

FC-D2-B6   (hex)		NREAL TECHNOLOGY LIMITED
A00000-AFFFFF     (base 16)		NREAL TECHNOLOGY LIMITED
				RM 1901，19/F LEE GARDEN ONE 33 HYSAN AVENUE CAUSEWAY BAY
				HONG KONG    999077
				HK

74-5B-C5   (hex)		Haikou Frun Flash&Mcu Microcontrol Technology Development Co.,Ltd
900000-9FFFFF     (base 16)		Haikou Frun Flash&Mcu Microcontrol Technology Development Co.,Ltd
				5 floor A1-9, A building, incubation center, Haikou national hi tech Development Zone
				Haikou  Hainan  570206
				CN

74-5B-C5   (hex)		Smartiply Inc.
B00000-BFFFFF     (base 16)		Smartiply Inc.
				233 Mt. Airy Road
				Basking Ridge  NJ  07920
				US

74-5B-C5   (hex)		OXON AG
300000-3FFFFF     (base 16)		OXON AG
				Waldeggstrasse 47
				Liebefeld    3097
				CH

E4-4C-C7   (hex)		HANGZHOU OLE-SYSTEMS CO., LTD
600000-6FFFFF     (base 16)		HANGZHOU OLE-SYSTEMS CO., LTD
				 No.35 Jiuhuan Road, Jianggan District , Hangzhou , Zhejiang , China
				Hangzhou  Zhejiang  310019
				CN

E4-4C-C7   (hex)		Channel Enterprises (HK) Ltd.
700000-7FFFFF     (base 16)		Channel Enterprises (HK) Ltd.
				Room 2006, 20/F., 43-47 Wang Lung Street,
				Tsuen Wan    NA
				HK

E4-4C-C7   (hex)		CE LABS, LLC
500000-5FFFFF     (base 16)		CE LABS, LLC
				3209 WOOD DRIVE
				GARLAND  TX  75041
				US

E0-5A-9F   (hex)		Shenzhen Rongan Networks Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Shenzhen Rongan Networks Technology Co.,Ltd
				Room 1903, Industrial and Research building of Sun Yat-Sen university,no.1, Yuexing 4th road, Yuehai street,Nanshan district
				Shenzhen  Guangdong  518057
				CN

E0-5A-9F   (hex)		Link of Things Co., Ltd.
300000-3FFFFF     (base 16)		Link of Things Co., Ltd.
				9F, Park St. 3-2, NanKang Software Park, Taipei, Taiwan
				Taipei    115
				TW

4C-BC-98   (hex)		Quake Global Inc
200000-2FFFFF     (base 16)		Quake Global Inc
				4711 VIEWRIDGE AVE., STE 150
				SAN DIEGO  CA  92123
				US

4C-BC-98   (hex)		Dongguan SmartAction Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Dongguan SmartAction Technology Co.,Ltd
				Room1109,Building D,First Place,Nancheng District, Dongguan
				Dongguan  Guangdong  523000
				CN

4C-BC-98   (hex)		Gronic Systems GmbH
500000-5FFFFF     (base 16)		Gronic Systems GmbH
				Hilpertswiese 7
				Birstein    63633
				DE

4C-BC-98   (hex)		Machine Max
300000-3FFFFF     (base 16)		Machine Max
				Shell Centre
				London    SE1 7NA
				GB

38-B1-9E   (hex)		Thrust Networks
600000-6FFFFF     (base 16)		Thrust Networks
				Pangeran Jayakarta 129 No B 7
				Jakarta  Jakarta  10730
				ID

D8-86-0B   (hex)		Teplovodokhran Ltd.
400000-4FFFFF     (base 16)		Teplovodokhran Ltd.
				Novaya , 51v
				Ryazan    390027
				RU

D8-86-0B   (hex)		DIGITAL CONCEPTS
900000-9FFFFF     (base 16)		DIGITAL CONCEPTS
				3108 RIVERPORT TECH CENTER DR
				MARYLAND HEIGHTS  MO  630434825
				US

E0-5A-9F   (hex)		Hale Products
400000-4FFFFF     (base 16)		Hale Products
				607 NW 27th Ave
				Ocala  FL  34475
				US

D8-86-0B   (hex)		GLO Science
A00000-AFFFFF     (base 16)		GLO Science
				10 West 37th Street, 1001
				New York  NY  10018
				US

D8-86-0B   (hex)		SCANMATIK
600000-6FFFFF     (base 16)		SCANMATIK
				Letnaya 18-2
				Mytischi  Moscow  141008
				RU

38-B1-9E   (hex)		Dallas Delta Corporation
D00000-DFFFFF     (base 16)		Dallas Delta Corporation
				102 Albert Street
				Brunswick East  Victoria  3057
				AU

38-B1-9E   (hex)		AVO DEVELOPMENT LTD
300000-3FFFFF     (base 16)		AVO DEVELOPMENT LTD
				179 Shepherds Hill
				Romford  Essex  RM3 0NR
				GB

84-39-BE   (hex)		HINO ENGINEERING, INC
000000-0FFFFF     (base 16)		HINO ENGINEERING, INC
				60-7 Takakuramachi
				Hachiouji  Tokyo  192-0033
				JP

CC-D3-9D   (hex)		Glenair
700000-7FFFFF     (base 16)		Glenair
				1211 Air Way
				Glendale  CA  91201
				US

D4-25-CC   (hex)		EISST Ltd
300000-3FFFFF     (base 16)		EISST Ltd
				10 Queen Street Place
				London    EC4R 1AG
				GB

D4-25-CC   (hex)		E-MetroTel
A00000-AFFFFF     (base 16)		E-MetroTel
				2828 West Parker Unit B201
				Plano  TX  75075
				US

D4-25-CC   (hex)		Coperion
E00000-EFFFFF     (base 16)		Coperion
				590 WOODBURY GLASSBORO RD.
				SEWELL  NJ  08080
				US

D4-25-CC   (hex)		NORDI TELEKOMMUNIKATSIOONI OÜ
000000-0FFFFF     (base 16)		NORDI TELEKOMMUNIKATSIOONI OÜ
				Valukoja 8
				Tallinn city  Estonian Republic  11415
				EE

CC-D3-9D   (hex)		MagTarget LLC
300000-3FFFFF     (base 16)		MagTarget LLC
				1300 Reamwood Ave Sunnyvale CA
				SUNNYVALE  CA  94089
				US

D4-25-CC   (hex)		Eware Information Technology com.,Ltd
100000-1FFFFF     (base 16)		Eware Information Technology com.,Ltd
				No.402,Building 5,Software Park,Keji Mid 3nd Road,Nanshan District
				Shenzhen  Guangdong  518057
				CN

9C-69-B4   (hex)		Teptron AB
900000-9FFFFF     (base 16)		Teptron AB
				Box 1009
				Varberg  Halland  43213
				SE

4C-91-7A   (hex)		LumiGrow Inc.
400000-4FFFFF     (base 16)		LumiGrow Inc.
				1480 64th Street, Suite #150
				Emeryville  CA  94608
				US

9C-69-B4   (hex)		Skydock do Brasil Ltda
800000-8FFFFF     (base 16)		Skydock do Brasil Ltda
				Rua Gralha Azul, 147
				Quatro Barras  PR  83420-000
				BR

9C-69-B4   (hex)		PCI Limited
700000-7FFFFF     (base 16)		PCI Limited
				35, Pioneer Road North
				Singapore    628475
				SG

6C-DF-FB   (hex)		AAON
600000-6FFFFF     (base 16)		AAON
				2425 Yukon Ave
				Tulsa  OK  74107
				US

6C-DF-FB   (hex)		CELL System Co.,Ltd.
B00000-BFFFFF     (base 16)		CELL System Co.,Ltd.
				1-2-8 Azamino-minami, Aobaku
				Yokohama  Kanagawa  225-0012
				JP

4C-91-7A   (hex)		Camsat Przemysław Gralak
800000-8FFFFF     (base 16)		Camsat Przemysław Gralak
				Ogrodowa 2A
				Solec Kujawski  Bydgoszcz  86-050
				PL

4C-91-7A   (hex)		Hangzhou Hangtu Technology Co.,Ltd.
900000-9FFFFF     (base 16)		Hangzhou Hangtu Technology Co.,Ltd.
				Room A301, no.11, xiyuan eighth road, xihu district
				Hangzhou  Zhejiang  310000
				CN

6C-DF-FB   (hex)		YongTechs Electric Co. Ltd
900000-9FFFFF     (base 16)		YongTechs Electric Co. Ltd
				18F-8, No.118, Ci-Yun Rd., Hsin Chu 30072, Taiwan(R.O.C.)
				Hsin Chu    30072
				TW

6C-DF-FB   (hex)		Hardmeier
800000-8FFFFF     (base 16)		Hardmeier
				Pärnu mnt 102
				Tallinn    11312
				EE

7C-BC-84   (hex)		Xuji Changnan Communication Equipment Co., Ltd.
700000-7FFFFF     (base 16)		Xuji Changnan Communication Equipment Co., Ltd.
				No. 2725, Xu You Xi Road
				Xuchang  Henan  461001
				CN

7C-BC-84   (hex)		OPNT BV
A00000-AFFFFF     (base 16)		OPNT BV
				De Boelelaan 1081
				Amsterdam    1081 HV
				NL

7C-BC-84   (hex)		Xiamen Mage Information Technology Co.,Ltd.
100000-1FFFFF     (base 16)		Xiamen Mage Information Technology Co.,Ltd.
				Room 302B, No.40 Guanri Road, Software Park II
				Xiamen  Fujian  361008
				CN

7C-BC-84   (hex)		Société de Transport de Montréal
600000-6FFFFF     (base 16)		Société de Transport de Montréal
				800, de La Gauchetière, bureau 8440
				Montréal  Québec  H5A 1J6
				CA

98-F9-C7   (hex)		ARIMA Communications Corp.
700000-7FFFFF     (base 16)		ARIMA Communications Corp.
				6F.,No.866,Zhongzheng Rd.,Zhonghe Dist.,
				New Taipei City  Taiwan  23586
				TW

0C-FE-5D   (hex)		Beijing WayClouds Technology Co., Ltd.
300000-3FFFFF     (base 16)		Beijing WayClouds Technology Co., Ltd.
				RM501, 5F, DASCOM BD,NO.9 SHANGDI EAST RD, HAIDIAN DISTRICT,BEIJING,CHINA
				Beijing    100085
				CN

98-F9-C7   (hex)		MSB Elektronik und Gerätebau GmbH
A00000-AFFFFF     (base 16)		MSB Elektronik und Gerätebau GmbH
				Hofwiesenstr. 23
				Crailsheim    74564
				DE

6C-5C-3D   (hex)		Reconova Technologies
B00000-BFFFFF     (base 16)		Reconova Technologies
				B103,Shenzhen Institute of Nanjing University,Keyuan Road,Hi-Tech Park,Nanshan District
				Shenzhen  Guangdong  518000
				CN

6C-5C-3D   (hex)		Syowatsusinkougyo Co.,Ltd.
D00000-DFFFFF     (base 16)		Syowatsusinkougyo Co.,Ltd.
				35 Ozekiazakitada,Azai-cho
				Ichinomiya-City  Aichi  491-0101
				JP

6C-5C-3D   (hex)		krtkl inc.
A00000-AFFFFF     (base 16)		krtkl inc.
				350 Townsend Street, Suite 301A
				San Francisco  CA  94107
				US

1C-FD-08   (hex)		A&B Technology
600000-6FFFFF     (base 16)		A&B Technology
				81, Geumnam-ro, Buk-gu
				Gwangju    61247
				KR

6C-5C-3D   (hex)		choyang powertech
C00000-CFFFFF     (base 16)		choyang powertech
				11. Deoksan-ro 189beon-gil.
				ilsan seo-gu. Goyang-si  Gyeonggi-do  10205
				KR

6C-5C-3D   (hex)		SOUNDKING ELECTRONICS&SOUND CO., LTD.
700000-7FFFFF     (base 16)		SOUNDKING ELECTRONICS&SOUND CO., LTD.
				No.818 Chengxin RoadYinzhou Investment Business Park
				Ningbo  Zhejiang  315105
				CN

1C-FD-08   (hex)		Beijing Hengxin Rainbow Information Technology Co.,Ltd
500000-5FFFFF     (base 16)		Beijing Hengxin Rainbow Information Technology Co.,Ltd
				11Floor,north district,newton business building,No.25 Landian factory south road，Haidian District
				Beijing  Beijing  100097
				CN

A8-3F-A1   (hex)		Exel s.r.l. unipersonale
B00000-BFFFFF     (base 16)		Exel s.r.l. unipersonale
				via di corticella 201
				bologna  BO  40128
				IT

A8-3F-A1   (hex)		Guangzhou Tupu Internet Technology Co., Ltd.
300000-3FFFFF     (base 16)		Guangzhou Tupu Internet Technology Co., Ltd.
				602, No.11, Jiangong Road, Tianhe Software Park, Tianhe District
				Guangzhou  Guangdong  510665
				CN

3C-6A-2C   (hex)		Bosch Automotive Products (Suzhou) Co., Ltd.
200000-2FFFFF     (base 16)		Bosch Automotive Products (Suzhou) Co., Ltd.
				No. 455 Xing Long Street
				Suzhou    215000
				CN

3C-6A-2C   (hex)		Phytium Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Phytium Technology Co., Ltd.
				Building 5, XinAn Business Square, Haiyuan Middle Road
				Binhai New District, Tianjin    300450
				CN

3C-6A-2C   (hex)		Qingdao iGuan Technology Co., Ltd.
500000-5FFFFF     (base 16)		Qingdao iGuan Technology Co., Ltd.
				Room416, Science and Technology Park, Ocean University of China, No.23 HongKongEast Road
				Qingdao  Shandong  266100
				CN

A8-3F-A1   (hex)		Zhejiang Wellsun Intelligent Technology Co.,Ltd.
400000-4FFFFF     (base 16)		Zhejiang Wellsun Intelligent Technology Co.,Ltd.
				No.15,Xingye East 3rd St.,Fuxi District,Tiantai County
				Taizhou  Zhejiang  317200
				CN

A8-3F-A1   (hex)		Shenzhen BIO I/E Co.,Ltd
D00000-DFFFFF     (base 16)		Shenzhen BIO I/E Co.,Ltd
				Huafan Industrial Park,Building #12, Henggang JianLong Village Industrial Zone, Longgang District
				Shenzhen  GuangDong province  518115
				CN

00-55-DA   (hex)		Private
F00000-FFFFFF     (base 16)		Private

30-0A-60   (hex)		Newtons4th Ltd
700000-7FFFFF     (base 16)		Newtons4th Ltd
				1 Bede Island Road
				Leicester    LE2 7EA
				GB

A4-ED-43   (hex)		TOEC TECHNOLOGY CO.，LTD.
E00000-EFFFFF     (base 16)		TOEC TECHNOLOGY CO.，LTD.
				6 Taishan Road Hexi District Tianjin China
				Tian Jin  Tian Jin  300211
				CN

A4-ED-43   (hex)		Dongguan Mingji Electronics technology Group Co., Ltd.
300000-3FFFFF     (base 16)		Dongguan Mingji Electronics technology Group Co., Ltd.
				NO.93,188 Industrial Road, Pingshan Village,Tangxia Town, Dongguan city, Guangdong Province , China.
				DONGGUAN  GUANGDONG  523710
				CN

A4-ED-43   (hex)		leakSMART
C00000-CFFFFF     (base 16)		leakSMART
				5920 GREENE POINTE DRIVE S  GROVEPORT
				Groveport  OH  43125
				US

A4-ED-43   (hex)		INGELABS S.L.
100000-1FFFFF     (base 16)		INGELABS S.L.
				Av. Juan Lopez Peñalver, 21
				Malaga  Malaga  29590
				ES

A0-28-33   (hex)		Kalray S.A.
C00000-CFFFFF     (base 16)		Kalray S.A.
				180 avenue de l’Europe
				Montbonnot Saint Martin    38330
				FR

84-89-EC   (hex)		BYDA Co. Ltd., 
700000-7FFFFF     (base 16)		BYDA Co. Ltd., 
				4F, KNS Bldg., 8, Gaepo-ro 25 gil, Gangnam-gu
				Seoul    06306
				KR

84-89-EC   (hex)		SHINKAWA LTD.
C00000-CFFFFF     (base 16)		SHINKAWA LTD.
				Shinjuku Front Tower 32F, 2-21-1 Kitashinjyuku
				Shinjuku-ku  Tokyo  169-0074
				JP

9C-F6-DD   (hex)		AVI Pty Ltd
A00000-AFFFFF     (base 16)		AVI Pty Ltd
				9 Pitt Way
				Booragoon  Western Australia  6154
				AU

30-09-F9   (hex)		Punkt Tronics AG
400000-4FFFFF     (base 16)		Punkt Tronics AG
				Via Losanna 4
				Lugano    6900
				CH

C0-83-59   (hex)		Beijing Cloud Fly Technology Development Co.Ltd
600000-6FFFFF     (base 16)		Beijing Cloud Fly Technology Development Co.Ltd
				No. 1703, Zhong An Sheng Ye Building, No. 168  Bei Yuan Road, Chaoyang District, Beijing
				Beijing  Beijing  100101
				CN

9C-F6-DD   (hex)		Capital Engineering & Research Incorporation Ltd.
400000-4FFFFF     (base 16)		Capital Engineering & Research Incorporation Ltd.
				NO.7 JianAnJie, Beijing Economic-Technological Development Area
				Beijing    100176
				CN

9C-F6-DD   (hex)		KXT Technology Co., Ltd.
700000-7FFFFF     (base 16)		KXT Technology Co., Ltd.
				3F. No.42, Sec. 2, Chongsin Rd., Sanchong Dist.
				New Taipei City    241
				TW

C0-83-59   (hex)		Gardner Denver Thomas GmbH
D00000-DFFFFF     (base 16)		Gardner Denver Thomas GmbH
				Livry-Gargan-Straße 10
				Fürstenfeldbruck  Bavaria  82256
				DE

04-C3-E6   (hex)		Amiosec Ltd
D00000-DFFFFF     (base 16)		Amiosec Ltd
				Unit 5 Miller Court
				Tewkesbury  Gloucestershire  GL20 8DN
				GB

04-C3-E6   (hex)		Innovusion Inc.
400000-4FFFFF     (base 16)		Innovusion Inc.
				4920 El Camino Real
				Los Altos  CA  94022
				US

04-C3-E6   (hex)		SLOC GmbH
800000-8FFFFF     (base 16)		SLOC GmbH
				Nikolaiplatz 4
				Graz  Styria  8020
				AT

B4-4B-D6   (hex)		SHENZHEN TITA INTERACTIVE TECHNOLOGY CO.,LTD
100000-1FFFFF     (base 16)		SHENZHEN TITA INTERACTIVE TECHNOLOGY CO.,LTD
				Floor 23, Haowei Technology Mansion,Keji south eighth Road, Gaoxin Sci-Tech. Park(South Zone), 
				Shenzhen  Guangdong  518000
				CN

D4-7C-44   (hex)		LS Communication Co.,Ltd.
500000-5FFFFF     (base 16)		LS Communication Co.,Ltd.
				LS Bldg., Hwachang-ro, 95(Seoksoo-dong), Manan-gu
				Anyang-city  Gyeonggi-do  13905
				KR

3C-42-7E   (hex)		ROBOX SMART MOTION (WUHU) CO.,LTD
D00000-DFFFFF     (base 16)		ROBOX SMART MOTION (WUHU) CO.,LTD
				No.96,Wanchun East Road,Jiujiang Economic Development District,Wuhu,Anhui,China
				Wuhu  Anhui  241000
				CN

3C-42-7E   (hex)		snap40 Ltd
A00000-AFFFFF     (base 16)		snap40 Ltd
				24 Forth Street
				Edinburgh    EH1 3LH
				GB

D4-7C-44   (hex)		Beijing Maystar Information Technology Co., Ltd.
800000-8FFFFF     (base 16)		Beijing Maystar Information Technology Co., Ltd.
				Building B 5/F,Shangdi Keji Zonghe Building,No.22 Shangdi Information Road, Haidian District
				Beijing    100084
				CN

A0-19-B2   (hex)		Ahgora Sistemas SA
E00000-EFFFFF     (base 16)		Ahgora Sistemas SA
				Rodovia José Carlos Daux (SC-401), 600 (Km 01) - ParqTec Alfa - Módulo 08
				Florianópolis  Santa Catarina  88030000
				BR

D4-7C-44   (hex)		ASDA ICT Co., Ltd.
600000-6FFFFF     (base 16)		ASDA ICT Co., Ltd.
				4F-2,No.2,Sec.4,Zhongyang Rd,Tucheng Dist,
				New Taipei City    999079
				TW

2C-48-35   (hex)		Scout Security, Inc.
500000-5FFFFF     (base 16)		Scout Security, Inc.
				210 N Racine Ave, STE 2M
				Chicago  IL  60607
				US

A0-19-B2   (hex)		MIS Industrie Systeme GmbH & Co. KG
800000-8FFFFF     (base 16)		MIS Industrie Systeme GmbH & Co. KG
				Lohwiese 7
				Scheuring  Bavaria  86937
				DE

A0-19-B2   (hex)		Beijing Deephi Intelligent Technology Co., Ltd
200000-2FFFFF     (base 16)		Beijing Deephi Intelligent Technology Co., Ltd
				7F Building D, Tsinghua Tongfang High-Tech PlazaRoom 1706, Building D-East, Tsinghua Tongfang High-Tech Plaza Haidian District, Beijing, 100083, China
				BEIJING  HAIDIAN  100083
				CN

2C-48-35   (hex)		Progress Rail Services, Inspection and Information Systems
000000-0FFFFF     (base 16)		Progress Rail Services, Inspection and Information Systems
				3801-1 South Selsa Road
				Independence  null  64057
				US

2C-48-35   (hex)		Newtrax Technologies Inc
300000-3FFFFF     (base 16)		Newtrax Technologies Inc
				360 St-Jacques, Floor 8 
				Montreal  Quebec  H2Y 1P5
				CA

2C-48-35   (hex)		Advanced Electronics Company Ltd
100000-1FFFFF     (base 16)		Advanced Electronics Company Ltd
				POBOX 90916, KKIA INDUSTRIAL ESTATE
				RIYADH  CENTRAL  11623
				SA

8C-1C-DA   (hex)		Septentrio NV
500000-5FFFFF     (base 16)		Septentrio NV
				Interleuvenlaan 15i
				Leuven    3001
				BE

8C-1C-DA   (hex)		CEOS Pty Ltd
000000-0FFFFF     (base 16)		CEOS Pty Ltd
				3/17 Burgundy Street,
				Heidelberg  VIC  3084
				AU

3C-24-F0   (hex)		Sivat Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Sivat Technology Co.,Ltd.
				Room 1602, Starbuilding 2, west Complex of ChangYing TianJie ChaoYang District
				BeiJing  Beijing  100024
				CN

8C-1C-DA   (hex)		Riegl Laser Measurement Systems GmbH
D00000-DFFFFF     (base 16)		Riegl Laser Measurement Systems GmbH
				Riedenburgstraße 48
				Horn  Niederösterreich  A-3580
				AT

8C-1C-DA   (hex)		K Technology Corporation
700000-7FFFFF     (base 16)		K Technology Corporation
				LIVMO Rising Bldg. 5F, 3-19-1
				Shin-Yokohama, Kohoku-ku, Yokohama, Kanagawa    222-0033
				JP

0C-73-EB   (hex)		Tiinlab Acoustic Technology (Shenzhen) Co., Ltd.
300000-3FFFFF     (base 16)		Tiinlab Acoustic Technology (Shenzhen) Co., Ltd.
				Tianliao Building F14 East Block (New Materials Industrial Park), Xueyuan Road, Nanshan District, 
				Shenzhen  Guangdong  518055
				CN

0C-73-EB   (hex)		D-Link （Shanghai）Limited Corp.
D00000-DFFFFF     (base 16)		D-Link （Shanghai）Limited Corp.
				Registered Address: Part J1, Floor 1, Building 2, No.115, Fute West First Road, China(Shanghai) Pilot Free Trade Zone
				Shanghai    200000
				CN

0C-73-EB   (hex)		Dinkle Enterprise Co., Ltd.
700000-7FFFFF     (base 16)		Dinkle Enterprise Co., Ltd.
				No.19, Wuquan 2nd Rd., Wugu Dist.
				New Taipei City    24890
				TW

0C-73-EB   (hex)		Synaccess Networks
B00000-BFFFFF     (base 16)		Synaccess Networks
				14425 N 79th St., Suite C
				Scottsdale  AZ  85260
				US

0C-73-EB   (hex)		Deltapath, Inc.
200000-2FFFFF     (base 16)		Deltapath, Inc.
				2107 N 1ST ST, STE 660
				San Jose  CA  95131
				US

0C-73-EB   (hex)		Pi Innovo LLC
A00000-AFFFFF     (base 16)		Pi Innovo LLC
				47023 Five Mile Rd
				Plymouth  MI  48170
				US

3C-24-F0   (hex)		Inter Action Corporation
600000-6FFFFF     (base 16)		Inter Action Corporation
				14F,Yokohama-Kanazawa High-Tech Center,1-1,
				Yokohama  Kanagawa  236-0004
				JP

3C-24-F0   (hex)		Siemens AG - Siemens Deutschland Mobility
900000-9FFFFF     (base 16)		Siemens AG - Siemens Deutschland Mobility
				Otto-Hahn-Ring 6
				Munich    81379
				DE

0C-73-EB   (hex)		Taiwan Pulse Motion Co., Ltd.
E00000-EFFFFF     (base 16)		Taiwan Pulse Motion Co., Ltd.
				5F.-11, No. 210, Gongyequ 38th Rd.
				Taichung City    40768
				TW

3C-24-F0   (hex)		COMATIS
B00000-BFFFFF     (base 16)		COMATIS
				8 rue Carnot
				SAINT-CYR-L'ECOLE    78210
				FR

48-65-EE   (hex)		SmartDisplayer Technology Co., Ltd.
800000-8FFFFF     (base 16)		SmartDisplayer Technology Co., Ltd.
				No. 2-1, Gongjian Rd., Qidu Dist, Keelung City, 20647, Taiwan (R.O.C.)
				Keelung    20647
				TW

48-0B-B2   (hex)		Annapurna labs
600000-6FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

48-0B-B2   (hex)		Popit Oy
B00000-BFFFFF     (base 16)		Popit Oy
				Metsänneidonkuja 6
				Espoo    02130
				FI

88-5F-E8   (hex)		Sonnet Labs Inc.
300000-3FFFFF     (base 16)		Sonnet Labs Inc.
				8 The Green Suite #6290
				Dover  DE  19901
				US

88-5F-E8   (hex)		Hauch & Bach ApS
500000-5FFFFF     (base 16)		Hauch & Bach ApS
				Femstykket 6
				Lynge    3540
				DK

88-5F-E8   (hex)		Sowee
900000-9FFFFF     (base 16)		Sowee
				4 place des Vosges
				Courbevoie    92400
				FR

88-5F-E8   (hex)		Red Technologies, LLC.
700000-7FFFFF     (base 16)		Red Technologies, LLC.
				34 Parker
				Irvine  CA  92618
				US

F0-41-C8   (hex)		Shenzhen Medica Technology Development Co., Ltd.
200000-2FFFFF     (base 16)		Shenzhen Medica Technology Development Co., Ltd.
				2F Building A, Tongfang Information Harbor, No.11, East Langshan Road, Nanshan District
				Shenzhen    518000
				CN

F0-41-C8   (hex)		 Shanghai Think-Force Electronic Technology Co. Ltd
C00000-CFFFFF     (base 16)		 Shanghai Think-Force Electronic Technology Co. Ltd
				North ZhongShan Road, No. 3000, Room 2608
				Shanghai    200000
				CN

F0-41-C8   (hex)		Shenzhen Umind Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Shenzhen Umind Technology Co., Ltd.
				Add: D2-6A, TCL Science Park, 1001 ZhongshanYuan Road, Nanshan District
				Shenzhen  Guangdong  581055
				CN

40-A3-6B   (hex)		SKS-Kinkel Elektronik GmbH
400000-4FFFFF     (base 16)		SKS-Kinkel Elektronik GmbH
				Im Industriegebiet 9
				Hof    56472
				DE

30-1F-9A   (hex)		MICOMSOFT CO.,LTD.
300000-3FFFFF     (base 16)		MICOMSOFT CO.,LTD.
				6F,KEIHAN-YODOYABASHI BLDG., 3-2-25,KITAHAMA,CHUO-KU
				osaka    541-0041
				JP

30-1F-9A   (hex)		HUNAN CHANGSHA HENGJIAN TECHNOLDGY DEVELPMENT CO.,LTD.
A00000-AFFFFF     (base 16)		HUNAN CHANGSHA HENGJIAN TECHNOLDGY DEVELPMENT CO.,LTD.
				Jiayun Road 209
				Changsha  Hunan  410205
				CN

88-A9-A7   (hex)		Sieper Lüdenscheid GmbH & Co. KG
600000-6FFFFF     (base 16)		Sieper Lüdenscheid GmbH & Co. KG
				Schlittenbacher Straße 60
				Lüdenscheid    58511
				DE

A4-DA-22   (hex)		SolidPro Technology Corporation
800000-8FFFFF     (base 16)		SolidPro Technology Corporation
				10F.-1, No.150, Jian 1st Rd.
				Zhonghe Dist.  New Taipei City  23511
				TW

DC-E5-33   (hex)		SAN Engineering
700000-7FFFFF     (base 16)		SAN Engineering
				434-31 UTO Korea BD. 4F
				Seongnam-si Jungwon-gu  Gyunggi-do  13230
				KR

DC-E5-33   (hex)		ShenZhen C&D Electronics CO.Ltd.
300000-3FFFFF     (base 16)		ShenZhen C&D Electronics CO.Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park,  Longhua New District
				ShenZhen  GuangDong  518000
				CN

C4-FF-BC   (hex)		KAGA ELECTRONICS CO.,LTD.
B00000-BFFFFF     (base 16)		KAGA ELECTRONICS CO.,LTD.
				20 Kandamatsunaga-cho
				Chiyoda-ku  TOKYO  101-8627
				JP

9C-43-1E   (hex)		Wireless Environment, LLC
400000-4FFFFF     (base 16)		Wireless Environment, LLC
				600 Beta Drive Unit 100 Mayfield Village, OH 44143,US
				Mayfield Village  OH  44143
				US

9C-43-1E   (hex)		Symfun Telecom Ltd
100000-1FFFFF     (base 16)		Symfun Telecom Ltd
				Floor 4 Building 11 Xi Qi Dian Jia Yuan
				Beijing    100083
				CN

9C-43-1E   (hex)		Optris GmbH
700000-7FFFFF     (base 16)		Optris GmbH
				Ferdinand-Buisson-Str. 14
				Berlin    13127
				DE

28-2C-02   (hex)		Shenzhen emb-star technology co. LTD
200000-2FFFFF     (base 16)		Shenzhen emb-star technology co. LTD
				2/f,building C,qinghu science park,qingxiang road,qinghu,longhua new district
				shenzhen  Guangdong  518131
				CN

F8-B5-68   (hex)		Whizpace Pte. Ltd.
B00000-BFFFFF     (base 16)		Whizpace Pte. Ltd.
				77 Ayer Rajah Crescent, #02-30
				Singapore    139954
				SG

F8-B5-68   (hex)		Maven Wireless AB
800000-8FFFFF     (base 16)		Maven Wireless AB
				Torshamnsgatan 35
				KISTA    164 40
				SE

40-48-FD   (hex)		Cloud4Wi
700000-7FFFFF     (base 16)		Cloud4Wi
				22 Cleveland St
				San Francisco  null  94103
				US

40-48-FD   (hex)		Ecotap B.V.
C00000-CFFFFF     (base 16)		Ecotap B.V.
				Industrieweg 4
				Boxtel    5281RW
				NL

40-48-FD   (hex)		Swarco Technology ApS
600000-6FFFFF     (base 16)		Swarco Technology ApS
				C. F. Tietgens Boulevard 25
				Odense SØ  Danmark  5220
				DK

40-48-FD   (hex)		MITHRAS Technology Co., LTD
200000-2FFFFF     (base 16)		MITHRAS Technology Co., LTD
				4F.-3, No. 880, Zhongzheng Rd., Zhonghe Dist., 
				New Taipei    23586
				TW

38-73-EA   (hex)		Light Blue Optics Ltd.
400000-4FFFFF     (base 16)		Light Blue Optics Ltd.
				St John's Innovation Centre, Cowley Road
				Cambridge  Cambridgeshire  CB40WS
				GB

EC-9F-0D   (hex)		CRRC QINGDAO SIFANG ROLLING STOCK RESEARCH INSTITUTE CO.,LTD
B00000-BFFFFF     (base 16)		CRRC QINGDAO SIFANG ROLLING STOCK RESEARCH INSTITUTE CO.,LTD
				No.231 Ruichang Road Qingdao City
				Qingdao  Shandong  266000
				CN

38-73-EA   (hex)		ISTCONTROL
500000-5FFFFF     (base 16)		ISTCONTROL
				#1203, 37 Maebongsan-ro, Mapo-gu
				Seoul    03909
				KR

EC-9F-0D   (hex)		flexlog GmbH
A00000-AFFFFF     (base 16)		flexlog GmbH
				Zur Gießerei 4
				Karlsruhe    76227
				DE

34-D0-B8   (hex)		Skytech Creations Limited
900000-9FFFFF     (base 16)		Skytech Creations Limited
				Flat F, 23/F., Block 2, Kingswin Industrial Building, 32-50 Lei Muk Road
				Kwai Chung    000000
				HK

34-D0-B8   (hex)		Glory Mark Electronic Ltd. Taiwan Branch (B.V.I.)
C00000-CFFFFF     (base 16)		Glory Mark Electronic Ltd. Taiwan Branch (B.V.I.)
				3F, No. 6, Lane 148, Li De St., Chungho Dist.
				New Taipei City  Taiwan  235
				TW

34-D0-B8   (hex)		EQPlay Intelligent Technology(Kunshan) Co,Ltd.
400000-4FFFFF     (base 16)		EQPlay Intelligent Technology(Kunshan) Co,Ltd.
				No. 58 Xinnengyuan Road, Yushan Town, Kunshan
				Kunshan  Jiangsu  215300
				CN

AC-1D-DF   (hex)		Sichuan Odot Automation System Co.,Ltd.
800000-8FFFFF     (base 16)		Sichuan Odot Automation System Co.,Ltd.
				No.6,Hongsheng Street
				MianYang  SiChuan  621102
				CN

AC-1D-DF   (hex)		ConectaIP Tecnologia S.L.
200000-2FFFFF     (base 16)		ConectaIP Tecnologia S.L.
				Novell 58, 4.2
				Barcelona    08014
				ES

34-D0-B8   (hex)		NTX Embedded
D00000-DFFFFF     (base 16)		NTX Embedded
				4275 Kellway Circle, Suite #106
				Addison  TX  75001
				US

AC-1D-DF   (hex)		Solare Datensysteme GmbH
900000-9FFFFF     (base 16)		Solare Datensysteme GmbH
				Fuhrmannstraße 9
				Geislingen-Binsdorf  Baden-Wuerttemberg  72351
				DE

CC-22-37   (hex)		Tolomatic, Inc.
B00000-BFFFFF     (base 16)		Tolomatic, Inc.
				3800 County Road 116
				Hamel  MN  55340
				US

74-1A-E0   (hex)		ITS Partner (O.B.S) S.L.
E00000-EFFFFF     (base 16)		ITS Partner (O.B.S) S.L.
				Av. Corts Catalanes 9-11 
				Sant Cugat del Valles  Barcelona  08173
				ES

CC-22-37   (hex)		MANUFACTURAS Y TRANSFORMADOS AB, S.L.
E00000-EFFFFF     (base 16)		MANUFACTURAS Y TRANSFORMADOS AB, S.L.
				SANT ANTONI DE BAIX, 110-112
				IGUALADA  BARCELONA  08700
				ES

74-1A-E0   (hex)		BÄR Bahnsicherung AG
700000-7FFFFF     (base 16)		BÄR Bahnsicherung AG
				Luppmenstrasse 3
				Fehraltorf     8320
				CH

74-1A-E0   (hex)		Broadcast Wireless Systems Ltd
800000-8FFFFF     (base 16)		Broadcast Wireless Systems Ltd
				Unit 9, Swanwick Business Centre, Bridge Road
				Southampton  Hampshire  SO31 7GB
				GB

04-71-4B   (hex)		Shenzhen WayOS Technology Crop., Ltd.
200000-2FFFFF     (base 16)		Shenzhen WayOS Technology Crop., Ltd.
				F18, Yousong Business Building, Longhua New Districe, Shenzhen, China
				Shenzhen  Guangdong  518109
				CN

CC-22-37   (hex)		Apeiron Data Systems
200000-2FFFFF     (base 16)		Apeiron Data Systems
				81 Blue Ravine Road
				Folsom  CA  95630
				US

2C-27-9E   (hex)		Amaryllo International Inc.
E00000-EFFFFF     (base 16)		Amaryllo International Inc.
				4F, No. 159, Xianzheng 9th Rd.,
				ZUHUBEI CITY  HSINCHU COUNTY  302
				TW

2C-27-9E   (hex)		octoScope, Inc.
900000-9FFFFF     (base 16)		octoScope, Inc.
				305 Foster Street, #104
				Littleton  MA  01460
				US

2C-27-9E   (hex)		Institut Dr. Foerster GmbH & Co. KG
800000-8FFFFF     (base 16)		Institut Dr. Foerster GmbH & Co. KG
				In Laisen 70
				Reutlingen    72766
				DE

CC-22-37   (hex)		SHENZHEN HOOENERGY TECHNOLOGY CO.,LTD
D00000-DFFFFF     (base 16)		SHENZHEN HOOENERGY TECHNOLOGY CO.,LTD
				NO.5C3-5,BLOCK CD,TIANZHANDASHA,FUTIAN DISTRICT
				SHENZHEN    518000
				CN

2C-27-9E   (hex)		Shijiazhuang King Transportation Equipment Co.,Ltd
400000-4FFFFF     (base 16)		Shijiazhuang King Transportation Equipment Co.,Ltd
				No.255 Changjiang Road
				Shijiazhuang  Hebei  050000
				CN

18-9B-A5   (hex)		Shenzhen Tong Tai Yi information Technology Co.,Ltd
800000-8FFFFF     (base 16)		Shenzhen Tong Tai Yi information Technology Co.,Ltd
				District C，3rd Floor，Bldg B1,Digital Tech Park,7th GaoXin South Blvd,Tech Park,NanShan，ShenZhen，China
				shenzhen  guangdong  518102
				CN

84-39-BE   (hex)		ShenZhen Fudeyu Technology co.,Ltd
300000-3FFFFF     (base 16)		ShenZhen Fudeyu Technology co.,Ltd
				1st Floor, Building C, No.3 Jinyuan Road, Heao Strict, Henggang Street, Longgang Area, Shenzhen.
				Shenzhen  Guangdong province  518115
				CN

18-9B-A5   (hex)		PHINETWORKS
300000-3FFFFF     (base 16)		PHINETWORKS
				412, Woorim E-Biz Center 2, Digital ro 33 gil
				Seoul  Guro gu  08377
				KR

34-29-8F   (hex)		Nanjing Sandemarine Electric Co.,Ltd
800000-8FFFFF     (base 16)		Nanjing Sandemarine Electric Co.,Ltd
				Room 202, D Building, No.2 Dongda Road, Pukou District, Nanjing, Jiangsu Province, P.R.China
				Nanjing  Jiangsu  210032
				CN

90-4E-91   (hex)		SKODA ELECTRIC a.s.
D00000-DFFFFF     (base 16)		SKODA ELECTRIC a.s.
				Tylova 1/57
				Plzen    301 28
				CZ

18-9B-A5   (hex)		APANA Inc.
900000-9FFFFF     (base 16)		APANA Inc.
				4290 Pacific Hwy A
				Bellingham  WA  98226
				US

90-4E-91   (hex)		Wrtnode technology Inc.
400000-4FFFFF     (base 16)		Wrtnode technology Inc.
				Dingsi Lu #18, Shahe, Changping Dist.
				Beijing    102209
				CN

34-29-8F   (hex)		Schnick-Schnack-Systems GmbH
B00000-BFFFFF     (base 16)		Schnick-Schnack-Systems GmbH
				Mathias-Brüggen Str. 79
				Koeln    50829 
				DE

34-29-8F   (hex)		Chengdu Meross Technology Co., Ltd.
100000-1FFFFF     (base 16)		Chengdu Meross Technology Co., Ltd.
				No. 25, Yizhou Avenue, Gaoxin
				Chengdu  Sichuan  610000
				CN

34-29-8F   (hex)		Bellman & Symfon
600000-6FFFFF     (base 16)		Bellman & Symfon
				Södra Långebergsgatan 30
				Västra Frölunda    42132
				SE

34-00-8A   (hex)		SHENZHEN WXL ELECTRONICS CO., LTD.
E00000-EFFFFF     (base 16)		SHENZHEN WXL ELECTRONICS CO., LTD.
				Internet Industry Base,Baoyuan Road,Bao'an District
				Shenzhen    518100
				CN

34-00-8A   (hex)		Project Engineering srl
B00000-BFFFFF     (base 16)		Project Engineering srl
				Via Colle Ramole 11
				Impruneta  FI  50023
				IT

34-29-8F   (hex)		Virtual Trunk Pte Ltd
A00000-AFFFFF     (base 16)		Virtual Trunk Pte Ltd
				12 Kallang Avenue 
				Aperia #04-30    339511
				SG

34-29-8F   (hex)		Beijing Vorx Telecommunications Co., Ltd.
300000-3FFFFF     (base 16)		Beijing Vorx Telecommunications Co., Ltd.
				No.3 Minzhuang Rd, Haidian District
				Beijing    100195
				CN

34-00-8A   (hex)		Angee Technologies Ltd.
000000-0FFFFF     (base 16)		Angee Technologies Ltd.
				City House, 3 Cranwood Street
				London     EC1V 9PE
				GB

78-D8-00   (hex)		Shenzhen Envicool Information Technology Co., Ltd
100000-1FFFFF     (base 16)		Shenzhen Envicool Information Technology Co., Ltd
				Building 9, Hongxin Industrial Park, Guanlan, Longhua District, 
				Shenzhen  Guangdong  518110
				CN

78-D8-00   (hex)		Shenzhen Scodeno Technology Co,. Ltd.
300000-3FFFFF     (base 16)		Shenzhen Scodeno Technology Co,. Ltd.
				New Longhua District，Guanlan rich Industrial Zone No. 22，Silicon Valley Power Digital Industrial Park A6 Building 2 floor
				Shenzhen  Guangdong  518110
				CN

78-D8-00   (hex)		Shenzhen Chenzhuo Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Shenzhen Chenzhuo Technology Co., Ltd.
				301,3/F,Longtangge,1183 Liuxian Avenue,Nanshan
				Shenzhen  Guangdong  518055
				CN

78-D8-00   (hex)		Salunda Ltd
800000-8FFFFF     (base 16)		Salunda Ltd
				6 Avonbury Business Park, Howes Lane
				Bicester  Oxon  Ox26 2UA
				GB

7C-BA-CC   (hex)		ALPHA TECHNOLOGIES, LLC
E00000-EFFFFF     (base 16)		ALPHA TECHNOLOGIES, LLC
				3030 GILCHRIST ROAD
				AKRON  OH  44305
				US

7C-BA-CC   (hex)		Flying Loft Inc.
C00000-CFFFFF     (base 16)		Flying Loft Inc.
				Rm. 1602, 16th floor, JNK Digital Tower 111
				Seoul    08390
				KR

F8-8A-3C   (hex)		Avateq Corp.
E00000-EFFFFF     (base 16)		Avateq Corp.
				3555 - 14th Ave., Unit 18
				Markham  ON  L3R 0H5
				CA

40-A3-6B   (hex)		SFT Co., Ltd.
800000-8FFFFF     (base 16)		SFT Co., Ltd.
				2-7-11
				Yamato-shi  Fukaminishi  242-0018
				JP

4C-65-A8   (hex)		High Infinity Germany
E00000-EFFFFF     (base 16)		High Infinity Germany
				Freiburgerstr. 9
				Emmendingen  Deutschland  79312
				DE

4C-65-A8   (hex)		Nuviz Oy
600000-6FFFFF     (base 16)		Nuviz Oy
				Joensuunkatu 7
				Salo    24100
				FI

F8-8A-3C   (hex)		FARA AS
B00000-BFFFFF     (base 16)		FARA AS
				Sjøgangen 4
				Trondheim    NO-7010
				NO

F8-8A-3C   (hex)		ART SPA
000000-0FFFFF     (base 16)		ART SPA
				VOC.PISCHIELLO, 20
				PASSIGNANO SUL TRASIMENO  PG  06065
				IT

8C-14-7D   (hex)		Nanjing bilian information Technology Co.,Ltd.
400000-4FFFFF     (base 16)		Nanjing bilian information Technology Co.,Ltd.
				Room 407,Building 1,No.8.Huayuan Road,Xuanwu District,Nanjing
				Nanjing  Jiangsu   210000
				CN

8C-14-7D   (hex)		Bluemega Document & Print Services
A00000-AFFFFF     (base 16)		Bluemega Document & Print Services
				1 Allée de Londres - Batiment Les Bénares
				Villejust  Essonne  91140
				FR

4C-65-A8   (hex)		Instant Byte, S.L.
800000-8FFFFF     (base 16)		Instant Byte, S.L.
				Calle Julio Palacios, 10 Naves 1-5, Pol. Ind. Ntra. Sra. de Butarque
				Leganés  Madrid  28914
				ES

4C-65-A8   (hex)		Orica Europe Pty Ltd & Co KG
200000-2FFFFF     (base 16)		Orica Europe Pty Ltd & Co KG
				Muelheimer Strasse 5
				Troisdorf  NRW  53840
				DE

A0-C5-F2   (hex)		UnaliWear, Inc.
D00000-DFFFFF     (base 16)		UnaliWear, Inc.
				3410 Cherry Lane
				Austin  TX  78703
				US

A0-C5-F2   (hex)		Impulse Networks Pte Ltd
900000-9FFFFF     (base 16)		Impulse Networks Pte Ltd
				1 Raffles Place, #44-08 Raffles Place
				Singapore    048616
				SG

50-FF-99   (hex)		IPC Global
400000-4FFFFF     (base 16)		IPC Global
				4 Wadhurst Drive
				Boronia  Victoria  3155
				AU

A0-C5-F2   (hex)		CoolR Group Inc
800000-8FFFFF     (base 16)		CoolR Group Inc
				14100 Parke Long Ct Suite I
				Chantilly  VA  20151
				US

A0-C5-F2   (hex)		Glooko inc
C00000-CFFFFF     (base 16)		Glooko inc
				899 W. Evelyn Avenue
				Mountain View  CA  94041
				US

F0-23-B9   (hex)		Xiamen Jinhaode Electronic Co.,Ltd
600000-6FFFFF     (base 16)		Xiamen Jinhaode Electronic Co.,Ltd
				2003# Fuyu Build, Changqing Road 536, Siming
				Xiamen  Fujian  361009
				CN

F0-23-B9   (hex)		Aquametro AG
000000-0FFFFF     (base 16)		Aquametro AG
				Ringstr. 75
				Therwil    4106
				CH

F0-23-B9   (hex)		G3 TECHNOLOGIES< INC
800000-8FFFFF     (base 16)		G3 TECHNOLOGIES< INC
				2904 BACK ACRE CIRCLE, STE 107
				MOUNT AIRY  MD  21771
				US

04-71-4B   (hex)		Gimso Mobile Ltd
E00000-EFFFFF     (base 16)		Gimso Mobile Ltd
				16 Hatidhar St
				Raanana    4366518
				IL

F0-23-B9   (hex)		EZVIS LIMITED
400000-4FFFFF     (base 16)		EZVIS LIMITED
				FLAT/RM 1605A Ho KING COMMERCIAL CENTRE 2-16 FA YUEN STREET
				HONGKONG    999077
				HK

60-D7-E3   (hex)		Avalun
000000-0FFFFF     (base 16)		Avalun
				7 parvis louis neel
				grenoble    38000
				FR

60-D7-E3   (hex)		Wilderness Labs Inc.
A00000-AFFFFF     (base 16)		Wilderness Labs Inc.
				700 Edgewater Blvd., #108
				Foster City  CA  94404
				US

60-D7-E3   (hex)		Revol Technologies inc
500000-5FFFFF     (base 16)		Revol Technologies inc
				5336 Queen Mary   Cote-St-Lu, APT#5
				montreal  QC  H3X1T8
				CA

60-D7-E3   (hex)		SKS Automaatio oy
300000-3FFFFF     (base 16)		SKS Automaatio oy
				Martinkylantie 50
				Vantaa    01720
				FI

08-ED-02   (hex)		D2SLink Systems
000000-0FFFFF     (base 16)		D2SLink Systems
				47 Rue Marcel Dassault
				Boulogne Billancourt    92514
				FR

08-ED-02   (hex)		Imperx, Inc
100000-1FFFFF     (base 16)		Imperx, Inc
				6421 Congress Avenue
				Boca Raton  FL  33487
				US

98-AA-FC   (hex)		Comarch S.A. 
E00000-EFFFFF     (base 16)		Comarch S.A. 
				Al. Jana Pawla II 39A
				Krakow  Poland  31-864
				PL

98-AA-FC   (hex)		BEAM Authentic
900000-9FFFFF     (base 16)		BEAM Authentic
				25 Tamalpais Avenue, Suite C
				San Anselmo  CA  94960
				US

98-AA-FC   (hex)		dots Inc.
C00000-CFFFFF     (base 16)		dots Inc.
				10F WiL Office, Izumi Garden Tower, 1-6-1 Roppongi, Minatoku
				Tokyo  Tokyo  1066010
				JP

14-4F-D7   (hex)		D&S Cable Industries (HK) Limited
C00000-CFFFFF     (base 16)		D&S Cable Industries (HK) Limited
				11th Floor,AXA Centre, 151 Gloucester Road Hong Kong
				HONGKONG    999077
				CN

14-4F-D7   (hex)		FedEx Services OTI
200000-2FFFFF     (base 16)		FedEx Services OTI
				920 W Poplar Ave, Suite 101
				Collierville  TN  38017
				US

14-4F-D7   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

F8-02-78   (hex)		BETTINI SRL
700000-7FFFFF     (base 16)		BETTINI SRL
				VIA CESARE BATTISTI 22
				CESANO MADERNO  MILAN  20031
				IT

14-4F-D7   (hex)		NPort Networks Inc.,
800000-8FFFFF     (base 16)		NPort Networks Inc.,
				9F No. 242 BaoAi street, ShuLin District,
				New Taipei  Taiwan  23845
				TW

14-4F-D7   (hex)		Zehnder Group AG
100000-1FFFFF     (base 16)		Zehnder Group AG
				Moortalstrasse 1
				Gränichen    CH-5722 
				CH

A4-11-63   (hex)		Dspread Technology (Beijing) Inc.
800000-8FFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

A4-11-63   (hex)		Pax
300000-3FFFFF     (base 16)		Pax
				4 cresswell gardens
				london  England  sw5 0bj
				GB

1C-A0-D3   (hex)		Dynamic Connect (Suzhou) Hi-Tech Electronic Co.,Ltd.
500000-5FFFFF     (base 16)		Dynamic Connect (Suzhou) Hi-Tech Electronic Co.,Ltd.
				Unit C&D, No.201 WuXiang, Export Processing Zone A No.200Suhong Road SIP
				Suzhou  JiangSu  215021
				CN

1C-A0-D3   (hex)		NPO TELECOM JSC
400000-4FFFFF     (base 16)		NPO TELECOM JSC
				31, Votkinskoe shosse str.
				Izhevsk  Udmurtia  426039
				RU

1C-A0-D3   (hex)		Intertecno SRL NISUTA
600000-6FFFFF     (base 16)		Intertecno SRL NISUTA
				Av. Belgrano 1209
				Capital Federal  Buenos Aires  1093
				AR

1C-A0-D3   (hex)		SAVELEC
300000-3FFFFF     (base 16)		SAVELEC
				rue de la houille blanche
				HERMILLON  SAVOIE  73300
				FR

40-F3-85   (hex)		KATO ENGINEERING INC.
500000-5FFFFF     (base 16)		KATO ENGINEERING INC.
				2075 HOWARD DRIVE WEST
				NORTH MANKATO   MN  56003
				US

40-F3-85   (hex)		BBB Inc.
E00000-EFFFFF     (base 16)		BBB Inc.
				28, Yatap-ro, Bundang-gu
				Seongnam-si  Gyeonggi-do  13522
				KR

8C-C8-F4   (hex)		ITECH Electronic Co.,ltd.
400000-4FFFFF     (base 16)		ITECH Electronic Co.,ltd.
				No.108, XiShanqiao Nanlu
				Nanjing  Jiangsu  210039
				CN

34-04-9E   (hex)		ND SatCom GmbH
E00000-EFFFFF     (base 16)		ND SatCom GmbH
				Graf-von-Soden-Straße
				Immenstaad  Baden-Württemberg  88090
				DE

34-04-9E   (hex)		Seeiner Technology Co.,LTD
500000-5FFFFF     (base 16)		Seeiner Technology Co.,LTD
				floor 6,Building 14,No.1008 Xiangwang street,Hangzhou City,Zhejiang province
				hangzhou    311121
				CN

34-04-9E   (hex)		Nanjing Mythware Information Technology Co., Ltd.
300000-3FFFFF     (base 16)		Nanjing Mythware Information Technology Co., Ltd.
				Level 13, Unit 3, Zijin Entrepreneur R&D Centre, No.89 Shengli Road, Jiangning District
				Nanjing  Jiangsu  211106
				CN

A4-58-0F   (hex)		Finetree Communications Inc
E00000-EFFFFF     (base 16)		Finetree Communications Inc
				#406, Shinyatap Prugiocity2, Yanghyunro 405
				Seungnamsi    13439
				KR

7C-CB-E2   (hex)		Easy Broadband Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Easy Broadband Technology Co., Ltd.
				3rd Floor, Jinyanlong Building, Xisanqi Bridge, Haidian District, Beijing 100096, China
				Beijing  Beijing  100096
				CN

7C-CB-E2   (hex)		Hangzhou Kaicom Communication Co.,Ltd
700000-7FFFFF     (base 16)		Hangzhou Kaicom Communication Co.,Ltd
				12th Floor,Block B CONBA Building,No.288 jiangnan Avenue , Binjiang District, Hangzhou, China
				Hangzhou  Zhejiang  310051
				CN

50-0B-91   (hex)		Shenzhen Lucky Sonics Co .,Ltd
D00000-DFFFFF     (base 16)		Shenzhen Lucky Sonics Co .,Ltd
				201A, BLOCK 10 ROW 1, SHANGTUN VILLAGE HESHUIKOU COMMUNITY,GO NGMING STREET, GUANGMING DISTRICT
				SHENZHEN  GUANGDONG  518107
				CN

A4-58-0F   (hex)		CoAsia Microelectronics Corp.
500000-5FFFFF     (base 16)		CoAsia Microelectronics Corp.
				13F, No. 3-2, Park St. Nangang District
				Taipei    11503
				TW

50-0B-91   (hex)		Shenzhen zhong ju  Fiber optical Co.Ltd
E00000-EFFFFF     (base 16)		Shenzhen zhong ju  Fiber optical Co.Ltd
				3t Floor Build A .jin he Rui park .guan lan.
				Shen zhen  Guang dong  518000
				CN

A4-58-0F   (hex)		Shenzhen City billion Leiden science and Technology Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen City billion Leiden science and Technology Co., Ltd.
				Shenzhen City, Baoan District Songgang Street Community Goodrich Tantou Industrial Park plant building 2
				Shenzhen City  Guangdong Province  518000
				CN

1C-C0-E1   (hex)		Videri Inc.
400000-4FFFFF     (base 16)		Videri Inc.
				541 West 23rd Street
				New York  NY  10011
				US

50-0B-91   (hex)		Diamond Traffic Products, Inc
C00000-CFFFFF     (base 16)		Diamond Traffic Products, Inc
				76433 Alder Street
				Oakridge  OR  97463
				US

7C-CB-E2   (hex)		Heyuan Yongyida Technology Holdings Co.,Ltd.
000000-0FFFFF     (base 16)		Heyuan Yongyida Technology Holdings Co.,Ltd.
				Xin Yong Yi Science Park, GaoXin 3rd Road, High-tech Zone
				Heyuan  Guangdong  517000
				CN

7C-CB-E2   (hex)		Astrum Technologies CC
300000-3FFFFF     (base 16)		Astrum Technologies CC
				Unit 49, Sandton View Office Park, 1 Conduit Str, Lyme Park
				Johannesburg  Gauteng  2060
				ZA

24-4E-7B   (hex)		Tekelek Europe Ltd
000000-0FFFFF     (base 16)		Tekelek Europe Ltd
				Unit 118 Shannon Free zone
				Shannon  Co. Clare  
				IE

7C-CB-E2   (hex)		CeoTronics AG
100000-1FFFFF     (base 16)		CeoTronics AG
				Adam-Opel-Str. 6
				Roedermark  Hessen  63322
				DE

24-4E-7B   (hex)		Shenzhen AWT science &  technology limited
A00000-AFFFFF     (base 16)		Shenzhen AWT science &  technology limited
				22E of Huari Building,Nanhua Garden,South Of Huaqiang Road,Futian Area
				Shenzhen    518057
				CN

4C-E1-73   (hex)		DAIKOKU DENKI CO.,LTD.
600000-6FFFFF     (base 16)		DAIKOKU DENKI CO.,LTD.
				1-43-5 Nagono Nakamura-ku
				Nagoya  Aichi  450-8640
				JP

48-65-EE   (hex)		EnBW Energie Baden-Württemberg AG
B00000-BFFFFF     (base 16)		EnBW Energie Baden-Württemberg AG
				Durlacher Allee 93
				Karlsruhe    76131
				DE

48-65-EE   (hex)		Gopod Group Limited
100000-1FFFFF     (base 16)		Gopod Group Limited
				5-6/f,building 8,Lianjian Industrial Park,Longhua
				Shenzhen    518109
				CN

24-4E-7B   (hex)		UniMAT Automation Technology Co., Ltd.
900000-9FFFFF     (base 16)		UniMAT Automation Technology Co., Ltd.
				 5/F, Building 15&16, Wisdomland Business Park, Road 2 Nantou port, Nanshan District
				Shenzhen   Guangdong   518052
				CN

48-65-EE   (hex)		Winn Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Winn Technology Co.,Ltd
				Winn Tech Industrial Park Xianghe Rd.Xinmin Area，Chang an，Dongguan City Guangdong Province，China.
				Dongguan  Guangdong  523879
				CN

48-65-EE   (hex)		Data Technology Inc.
300000-3FFFFF     (base 16)		Data Technology Inc.
				Tachikawa Nishiki-cho Bldg 8F, 1-8-7 Nishiki-cho
				Tachikawa-shi  Tokyo  190-0022
				JP

4C-E1-73   (hex)		Nanjing Tongke Technology Development Co., LTD
800000-8FFFFF     (base 16)		Nanjing Tongke Technology Development Co., LTD
				8 Taishan Road jianye
				Nanjing    210000
				CN

1C-C0-E1   (hex)		HANGZHOU SOFTEL OPTIC CO., LTD
300000-3FFFFF     (base 16)		HANGZHOU SOFTEL OPTIC CO., LTD
				101 BINKANG ROAD, BINJIANG DISTRICT
				HANGZHOU  ZHEJIANG  310052
				CN

4C-E1-73   (hex)		Huizhou Dehong Technology Co., Ltd.
400000-4FFFFF     (base 16)		Huizhou Dehong Technology Co., Ltd.
				Dongxing
				Huizhou  Guangdong  516210
				CN

4C-E1-73   (hex)		Shanghai Ehong Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Shanghai Ehong Technology Co.,Ltd
				RM1505,blk 1st,No.833 South Hongmei Road Minhang Dis
				Shanghai   shanghai  200237
				CN

AC-64-DD   (hex)		DIGIBIRD TECHNOLOGY CO., LTD.
E00000-EFFFFF     (base 16)		DIGIBIRD TECHNOLOGY CO., LTD.
				LONGGUAN BUSINESS CENTER, SUITE 501. HUILONGGUAN W., ST., CHANGPING
				BEIJING  BEIJING  102208
				CN

1C-C0-E1   (hex)		SECHERON SA
A00000-AFFFFF     (base 16)		SECHERON SA
				Rue du Pre Bouvier 25
				SATIGNY  GENEVA  1242
				CH

4C-E1-73   (hex)		NewVastek
500000-5FFFFF     (base 16)		NewVastek
				5F., No.65, Shitan Rd.
				Taipei City  Neihu Dist.  11469
				TW

38-3A-21   (hex)		Chengdu Krosslan Technology Inc.
700000-7FFFFF     (base 16)		Chengdu Krosslan Technology Inc.
				4F,Tower B, Rennan Mansion, No.5 Section 3, 2nd Ring Road South
				Chengdu  Sichuan  610041
				CN

38-3A-21   (hex)		Skylark Wireless LLC
900000-9FFFFF     (base 16)		Skylark Wireless LLC
				1953 Richmond Ave.
				Houston  TX  77098
				US

38-3A-21   (hex)		SDNware technology co.,LTD
E00000-EFFFFF     (base 16)		SDNware technology co.,LTD
				166 Renai Road
				Suzhou    215000
				CN

AC-64-DD   (hex)		infypower Co., Ltd
300000-3FFFFF     (base 16)		infypower Co., Ltd
				-101, No. 3009, Shahexi Road, Nanshan District,
				shenzhen  guangdong  518055
				CN

38-3A-21   (hex)		Pactron
B00000-BFFFFF     (base 16)		Pactron
				3000 Patrick Henry 
				Santa Clara   CA  95054
				US

F8-1D-78   (hex)		ADTECHNO Inc.
100000-1FFFFF     (base 16)		ADTECHNO Inc.
				2-3-10 Kudanminami, Chiyoda-Ku
				Tokyo    102-0074
				JP

70-F8-E7   (hex)		Flexim Security Oy
600000-6FFFFF     (base 16)		Flexim Security Oy
				P.O.Box 700
				ESPOO  Southern Finland  02131
				FI

70-F8-E7   (hex)		Kontech Electronics Co., Ltd
900000-9FFFFF     (base 16)		Kontech Electronics Co., Ltd
				Longhua,Dalang,Langkou Industry Park
				shenzhen  Guangdong  518109
				CN

70-F8-E7   (hex)		SHENZHEN Xin JiuNing Electronics Co Ltd
000000-0FFFFF     (base 16)		SHENZHEN Xin JiuNing Electronics Co Ltd
				Floor 2, Building 11, WaiMao Industrial Park, Shiyan Subdistrict , Baoan District, Shenzhen
				SHENZHEN  GUANGDONG  518108
				CN

70-F8-E7   (hex)		Eclipse Security
800000-8FFFFF     (base 16)		Eclipse Security
				3900 N. 29th Ave
				Hollywood  FL  33020
				US

F8-1D-78   (hex)		SHENZHUOYUE TECHNOLOGY.,LTD
C00000-CFFFFF     (base 16)		SHENZHUOYUE TECHNOLOGY.,LTD
				Room 815/816 , ShangMei Times Building, No. 57  LongGuan East Road,Long Hua New District,
				Shenzhen  Guangdong  518000
				CN

70-F8-E7   (hex)		System Level Solutions (India) Pvt.
100000-1FFFFF     (base 16)		System Level Solutions (India) Pvt.
				32, D4, Phase-1, GIDC, V U Nagar
				Anand  Gujarat  388121
				IN

84-E0-F4   (hex)		iSolution Technologies Co.,Ltd.
A00000-AFFFFF     (base 16)		iSolution Technologies Co.,Ltd.
				5F,Bldg #6, Zhongguan Honghualing Industrial South Park
				Shenzhen  Guangdong  518055
				CN

84-E0-F4   (hex)		Dantherm
700000-7FFFFF     (base 16)		Dantherm
				Marienlystvej 65 
				Skive    7800
				DK

84-E0-F4   (hex)		Liaoning IK'SONYA Science and Technology Co., Ltd.
600000-6FFFFF     (base 16)		Liaoning IK'SONYA Science and Technology Co., Ltd.
				Floor9, Building E01, No.861-1 Shangshengoucun Dongling District Shenyang City Liaoning Province
				Shenyang    110000
				CN

84-E0-F4   (hex)		MedicusTek Inc.
100000-1FFFFF     (base 16)		MedicusTek Inc.
				9F No.3-2 Yuanqu St. Nangang Dist.
				Taipei    11503
				TW

84-E0-F4   (hex)		RAY Co.,LTD
800000-8FFFFF     (base 16)		RAY Co.,LTD
				3~4F, 332-7, Samsung1-ro
				Hwaseong-si  Gyeonggi-do  445-330
				KR

C0-D3-91   (hex)		XENA SECURITY LIMITED
800000-8FFFFF     (base 16)		XENA SECURITY LIMITED
				ROOM 1210, WANG CHEONG ENTERPRISE CENTRE, 65 CHAI WAN KOK STREET, TSUEN WAN, N.T.
				HONG KONG  Select State  000000
				HK

C0-D3-91   (hex)		Hofon Automation Co.,Ltd
200000-2FFFFF     (base 16)		Hofon Automation Co.,Ltd
				8th floor,3rd building of Lierda,No1328 Wenyi Road
				Hangzhou  Zhejiang  310000
				CN

98-6D-35   (hex)		blossom communications corp.
400000-4FFFFF     (base 16)		blossom communications corp.
				Floor 19, No. 104, Sec. 1, Sin Tai Wu Road, Xi Zhi District
				New Taipei City    221
				TW

C0-D3-91   (hex)		IXON B.V.
300000-3FFFFF     (base 16)		IXON B.V.
				Vierlingsbeekseweg 52A
				Overloon  Noord-Brabant  5825 AX
				NL

58-E8-76   (hex)		Chengdu Vision-Zenith Technology Co.,Ltd
800000-8FFFFF     (base 16)		Chengdu Vision-Zenith Technology Co.,Ltd
				3rd Floor,Unit 1 Building 6,No.88 of Tianchen Road West Science Park, Hi-tech zone west
				Chengdu  Sichuan  610000
				CN

58-E8-76   (hex)		SHENZHEN DIGISSIN TECHNOLOGY
A00000-AFFFFF     (base 16)		SHENZHEN DIGISSIN TECHNOLOGY
				Room 315, Zixinda Building, No. 1053, BAOYUAN Road, Xixiang, Baoan District,
				SHENZHEN  GUANGDONG  518102
				CN

58-E8-76   (hex)		KUSTOM SIGNALS INC
C00000-CFFFFF     (base 16)		KUSTOM SIGNALS INC
				1010 W CHESTNUT
				CHANUTE  KS  66720
				US

C0-D3-91   (hex)		REGULUS CO.,LTD.
D00000-DFFFFF     (base 16)		REGULUS CO.,LTD.
				Yotsuya  Orchid Bldg.  23-3 Daikyo-cho
				 Shinjuku-ku  Tokyo  160-0015
				JP

F0-AC-D7   (hex)		Sercomm Corporation.
400000-4FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

F0-AC-D7   (hex)		Hanju Network Technologies Co.
700000-7FFFFF     (base 16)		Hanju Network Technologies Co.
				lvdilanhai building 2303, zhangba street
				Xi'an  ShaanXi  710065
				CN

F0-AC-D7   (hex)		Telefonix Incorporated
800000-8FFFFF     (base 16)		Telefonix Incorporated
				2340 Ernie Krueger Circle
				Waukegan  null  60087
				US

F0-AC-D7   (hex)		PAVO TASARIM URETIM TICARET A.S.
500000-5FFFFF     (base 16)		PAVO TASARIM URETIM TICARET A.S.
				Teknopark Istanbul Ar-Ge Binalari 1.Blok Pendik
				Istanbul  Select State  34349
				TR

F0-AC-D7   (hex)		Suzhou Pairlink Network Technology
600000-6FFFFF     (base 16)		Suzhou Pairlink Network Technology
				Room304, Building 4, No.209, Zhu Yuan Road, Suzhou new district
				Suzhou  Jiangsu  215011
				CN

28-36-38   (hex)		Knowles Electronics LLC
000000-0FFFFF     (base 16)		Knowles Electronics LLC
				1151 Maplewood Drive
				Itasca  IL  60143
				US

28-36-38   (hex)		APPEAK Technology System Co.Ltd.
D00000-DFFFFF     (base 16)		APPEAK Technology System Co.Ltd.
				12F.,No176,Sec.2 Beixin Rd. 
				Xindian Dist  New Taipei City  231
				TW

28-36-38   (hex)		Dspread Technology (Beijing) Inc.
400000-4FFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

28-36-38   (hex)		Bluekey Pty Ltd
A00000-AFFFFF     (base 16)		Bluekey Pty Ltd
				6/28 Newheath Dr 
				Arundel  Queensland  4214
				AU

8C-19-2D   (hex)		You Zhengcheng co.,ltd
C00000-CFFFFF     (base 16)		You Zhengcheng co.,ltd
				Baoan District 45 District
				shenzhen  guangdong  518133
				CN

8C-19-2D   (hex)		Charmlink Tech(HK) Co.,Limited 
400000-4FFFFF     (base 16)		Charmlink Tech(HK) Co.,Limited 
				UNIT 04,7/F BRIGHT WAY TOWER NO.33 MONG KOK RD KL
				HONGKONG    999077
				HK

8C-19-2D   (hex)		SRETT
700000-7FFFFF     (base 16)		SRETT
				305 Avenue Le jour se lève
				Boulogne-Billancourt    92100
				FR

8C-19-2D   (hex)		Abside Networks, Inc.
B00000-BFFFFF     (base 16)		Abside Networks, Inc.
				16 heritage road
				Acton  MA  01720
				US

8C-19-2D   (hex)		ViaWear, Inc.
900000-9FFFFF     (base 16)		ViaWear, Inc.
				801 Key Route Blvd
				Albany  CA  94706
				US

8C-19-2D   (hex)		Shenzhen Cylan Technology Co.,Ltd
800000-8FFFFF     (base 16)		Shenzhen Cylan Technology Co.,Ltd
				Room 605.607.608,Minning Business Building,Caitian North Road,Futian District,Shenzhen
				Shenzhen  Guangdong  518036
				CN

CC-D3-1E   (hex)		Siemens AG, MO MLT BG
900000-9FFFFF     (base 16)		Siemens AG, MO MLT BG
				Eggenbergerstr. 31
				Graz  Styria  8020
				AT

D0-D9-4F   (hex)		DUKSANMECASYS CO., LTD.
D00000-DFFFFF     (base 16)		DUKSANMECASYS CO., LTD.
				7F The 6th Byucksan Digital Valley 481-4 Gasan-Dong Geumcheon-Gu 
				SEOUL    08501
				KR

C4-7C-8D   (hex)		GETEMED Medizin- und Informationstechnik AG
800000-8FFFFF     (base 16)		GETEMED Medizin- und Informationstechnik AG
				Oderstrasse 77
				Teltow  Brandenburg  14513
				DE

C4-7C-8D   (hex)		GC AUTOMATION CO,LTD
B00000-BFFFFF     (base 16)		GC AUTOMATION CO,LTD
				SECOND FLOOR,BLD 10,GRAIN INDUSTRIAL PARK,NO.299  GUANPING ROAD,GUANLAN NEW DISTRICT,SHENZHEN CITY,CHINA
				Shenzhen    518000
				CN

C4-7C-8D   (hex)		Silvus technologies inc
A00000-AFFFFF     (base 16)		Silvus technologies inc
				10990 Wilshire blvd. suite 1500
				Los Angeles   CA  90024
				US

C4-7C-8D   (hex)		ROBOSTAR
400000-4FFFFF     (base 16)		ROBOSTAR
				700, Suin-ro, Sangnok-gu
				Ansan-si  Kyŏnggi-do  426-220
				KR

68-91-D0   (hex)		Outstanding Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Outstanding Technology Co., Ltd.
				9th floor, New Yaesu bldg., 3-5-12 nihon-bashi
				Chuo-ku  Tokyo  103-0027
				JP

C4-7C-8D   (hex)		Watec Co., Ltd.
300000-3FFFFF     (base 16)		Watec Co., Ltd.
				254-2 Nihonkoku, Daihoji
				Tsuruoka-shi  Yamagata  997-0017
				JP

68-91-D0   (hex)		Multi Alarm Zrt.
100000-1FFFFF     (base 16)		Multi Alarm Zrt.
				Basamalom u. 33.
				Pécs  Baranya  7630
				HU

68-91-D0   (hex)		QUANTEX
900000-9FFFFF     (base 16)		QUANTEX
				010000, Republic of Kazakhstan, Astana, Dostyk st., 5/2, VP 3
				Astana    010000
				KZ

E0-B6-F5   (hex)		POMCube Inc. 
600000-6FFFFF     (base 16)		POMCube Inc. 
				19363 Brockton Ln
				Saratoga  CA  95070
				US

E0-B6-F5   (hex)		Huizhou GISUN Industrial CO. LTD
300000-3FFFFF     (base 16)		Huizhou GISUN Industrial CO. LTD
				Gisun Industry Park,Dong Ao Village, Sha Tian Town,HuiYang District ,Huizhou China
				Huizhou  Guangdong  518114
				CN

68-91-D0   (hex)		NIPK Electron Co.
500000-5FFFFF     (base 16)		NIPK Electron Co.
				Leningradskaya str. 52a. lit.A, pos. Pesochny
				Saint-Petersburg    197758
				RU

E0-B6-F5   (hex)		funktel GmbH
C00000-CFFFFF     (base 16)		funktel GmbH
				Windmühlenbergstr. 20-22
				Salzgitter    38259
				DE

50-FF-99   (hex)		 SHENZHEN KINGVT ELECTRONICS CO.,LTD
200000-2FFFFF     (base 16)		 SHENZHEN KINGVT ELECTRONICS CO.,LTD
				 8/F,NO.100,LANGKOU INDUSTRLAL PARK,DALANG STREET,NEW LONGHUA DISTRCT,SHENZHEN,R.R.C
				Shenzhen    518000
				CN

E0-B6-F5   (hex)		Yuneec International（China）Co.，Ltd
800000-8FFFFF     (base 16)		Yuneec International（China）Co.，Ltd
				388 Zhengwei Road,JinXi Town,Kunshan,Jiangsu,China
				Kunshan  Jiangsu  215300
				CN

98-6D-35   (hex)		Zhejiang Hanshow Technology Co., Ltd.
700000-7FFFFF     (base 16)		Zhejiang Hanshow Technology Co., Ltd.
				Floor 18, Building C, Ruipu Plaza, No.15,Hongjunying South Rd, Beijing, China
				beijing  beijing  100012
				CN

50-FF-99   (hex)		Honeywell International
700000-7FFFFF     (base 16)		Honeywell International
				13475 Danielson St # 100
				Poway  CA  92064
				US

7C-47-7C   (hex)		Shenzhen Eunicum Electric Co.,Ltd.
800000-8FFFFF     (base 16)		Shenzhen Eunicum Electric Co.,Ltd.
				3/F Building 11, Lishan Industrial Park, Yueliangwan,Nanshan District
				Shenzhen  Guangdong  518054
				CN

7C-47-7C   (hex)		Photosynth Inc.
100000-1FFFFF     (base 16)		Photosynth Inc.
				5-11-1 Sumitomo Seimei Gotanda Bldg. 3F
				Osaki, Shinagawa-ku  Tokyo  141-0032
				JP

7C-47-7C   (hex)		Zerosystem LTD.Co
600000-6FFFFF     (base 16)		Zerosystem LTD.Co
				#905 Hansol Technotown 455 Gyeongsu-Daero
				Gunpo  Gyeonggido  435-831 
				KR

98-6D-35   (hex)		Vitronic Dr.-Ing. Stein Bildverarbeitungssysteme GmbH
600000-6FFFFF     (base 16)		Vitronic Dr.-Ing. Stein Bildverarbeitungssysteme GmbH
				Hasengartenstraße 14
				Wiesbaden  Hessen  65189
				DE

98-6D-35   (hex)		Praesideo B.V.
D00000-DFFFFF     (base 16)		Praesideo B.V.
				P.O. Box 24008
				Utrecht    3502 MA
				NL

7C-47-7C   (hex)		BungBungame Inc
000000-0FFFFF     (base 16)		BungBungame Inc
				15F., No.19-11, Sanchong Rd., Nangang Dist., Taipei City 115, Taiwan (R.O.C.)
				Taipei    100
				TW

7C-47-7C   (hex)		Midwest Microwave Solutions
500000-5FFFFF     (base 16)		Midwest Microwave Solutions
				2000 Progress Drive
				Hiawatha  IA  52233
				US

5C-F2-86   (hex)		Daisen Electronic Industrial Co., Ltd.
E00000-EFFFFF     (base 16)		Daisen Electronic Industrial Co., Ltd.
				4-9-24 Nipponbashi, Naniwa-ku
				Osaka    556-0005
				JP

5C-F2-86   (hex)		Unfors Raysafe AB
A00000-AFFFFF     (base 16)		Unfors Raysafe AB
				Uggledalsvagen 29
				Billdal    42740
				SE

38-FD-FE   (hex)		New Telecom Solutions LLC
400000-4FFFFF     (base 16)		New Telecom Solutions LLC
				Kedrova 15
				Moscow  Moscow  117036
				RU

38-FD-FE   (hex)		CaptiveAire Systems Inc.
500000-5FFFFF     (base 16)		CaptiveAire Systems Inc.
				4641 Paragon Park
				Raleigh  NC  27616
				US

78-CA-83   (hex)		Elanview Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Elanview Technology Co.,Ltd
				NO.7001,Zhongchun Road,Minghang District, Shanghai
				shanghai  shanghai  201101
				CN

78-CA-83   (hex)		Beijing CarePulse Electronic Technology 
700000-7FFFFF     (base 16)		Beijing CarePulse Electronic Technology 
				#6302 Hua Yuan Shang Wo Hui Guan, Hua Yuan Dong Road 30, Hai Dian District
				BEIJING    100191
				CN

38-B8-EB   (hex)		CeeNex Inc
800000-8FFFFF     (base 16)		CeeNex Inc
				1200 Aerowood Drive  Unit 30
				Mississauga, ON  Canada L4W 2S7    L4W 2S7
				CA

78-CA-83   (hex)		IHM
800000-8FFFFF     (base 16)		IHM
				Vandtaarnsvej 87
				Soborg  Copenhagen  2860
				DK

78-CA-83   (hex)		Zhejiang Science Electronic Tech Co., Ltd
B00000-BFFFFF     (base 16)		Zhejiang Science Electronic Tech Co., Ltd
				F5, Huichuang Building ,No.88, Headquarters Business Garden
				Nanhu District, Jiaxing  Zhejiang  314000
				CN

1C-87-74   (hex)		Xiaoxinge (Tangshan) Electronic Technology Co., Ltd.
500000-5FFFFF     (base 16)		Xiaoxinge (Tangshan) Electronic Technology Co., Ltd.
				D9G Fuhua Plaza, 8# North Street, Chaoyangmen, Dongcheng District
				Beijing  Beijing  100027
				CN

1C-87-74   (hex)		New Nordic Engineering
C00000-CFFFFF     (base 16)		New Nordic Engineering
				Inge Lehmanns Gade 10
				Aarhus    8000
				DK

1C-88-79   (hex)		Toshiba Toko Meter Systems Co., LTD.
800000-8FFFFF     (base 16)		Toshiba Toko Meter Systems Co., LTD.
				3484, Sakuragaoka, Kurohama
				Hasuda-shi  Saitama  349-0192
				JP

1C-87-74   (hex)		Weber Marking Systems GmbH
400000-4FFFFF     (base 16)		Weber Marking Systems GmbH
				Maarweg 33
				Rheinbreitbach  Rheinland-Pfalz  53619
				DE

1C-87-74   (hex)		Ing Buero Ziegler
700000-7FFFFF     (base 16)		Ing Buero Ziegler
				Schönau
				Huetten    8825
				CH

1C-87-74   (hex)		CLABER SPA
D00000-DFFFFF     (base 16)		CLABER SPA
				VIA PONTEBBANA 22
				FIUME VENETO  PORDENONE  33080
				IT

1C-87-79   (hex)		Istria soluciones de criptografia, S. A.
900000-9FFFFF     (base 16)		Istria soluciones de criptografia, S. A.
				Calle la Fragua, 6
				Tres Cantos  Madrid  28760
				ES

1C-87-79   (hex)		Hangzhou Xiaowen Intelligent Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Hangzhou Xiaowen Intelligent Technology Co., Ltd.
				Room 610、611, F/6, Huaye Building,No.511, Jianye Road, Binjiang District
				Hang Zhou  Zhe Jiang  310053
				CN

1C-87-79   (hex)		ZHEJIANG ITENAL TECHNOLOGY CO.,LTD
800000-8FFFFF     (base 16)		ZHEJIANG ITENAL TECHNOLOGY CO.,LTD
				SHOES INDUSTRIAL PARK
				WENZHOU  ZHEJIANG  325401
				CN

1C-87-79   (hex)		A-GEAR COMPANY LIMITED 
100000-1FFFFF     (base 16)		A-GEAR COMPANY LIMITED 
				3F, Building 3, Unit 1, YingJunNianHa Park, LongGang Avenue, LongGang
				Shenzhen  Guangdong  518114
				CN

84-39-BE   (hex)		Shenzhen Horn Audio Co.,Ltd.
B00000-BFFFFF     (base 16)		Shenzhen Horn Audio Co.,Ltd.
				NO.6 4th GuiHua road,PingShan,
				Shenzhen  Guangdong  518118
				CN

84-39-BE   (hex)		Diamond Products LLC
800000-8FFFFF     (base 16)		Diamond Products LLC
				21350 Lassen St, Chatsworth, CA  91311, United States
				Chatsworth  CA  91311
				US

40-A3-6B   (hex)		Amobile Intelligent Corp.
B00000-BFFFFF     (base 16)		Amobile Intelligent Corp.
				18F-1 150 Jianyi Road
				New Taipei City    23511
				TW

40-A3-6B   (hex)		Pella Corporation
700000-7FFFFF     (base 16)		Pella Corporation
				102 Main St
				Pella  IA  50219
				US

40-A3-6B   (hex)		Omnitracs, LLC
300000-3FFFFF     (base 16)		Omnitracs, LLC
				717 North Harwood St.
				Dallas  TX  75201
				US

40-A3-6B   (hex)		Fin Robotics Inc
000000-0FFFFF     (base 16)		Fin Robotics Inc
				11871 Hilltop Dr, Losaltos Hills
				Los Altos  CA  94024
				US

80-0A-80   (hex)		Beijing Gooagoo Technical Service Co.,Ltd.
600000-6FFFFF     (base 16)		Beijing Gooagoo Technical Service Co.,Ltd.
				Room 402A,Block E,Wangjing Technology Park,Lize Road
				Beijing  Beijing  100102
				CN

80-0A-80   (hex)		Shenzhen Zidoo Technology Co., Ltd.
500000-5FFFFF     (base 16)		Shenzhen Zidoo Technology Co., Ltd.
				Room 12D,Block A CENTRAL GREAT SEARCHINGS,
				Shenzhen  Guangdong  518100
				CN

00-55-DA   (hex)		Donguan WideLink Communication Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Donguan WideLink Communication Technology Co.,Ltd.
				Guangdong dongguan songshan lake high new technology industry development zone industrial south road no. 6 3 building the second floor
				Dongguan city  Guangdong province  523808
				CN

00-55-DA   (hex)		LUCISTECHNOLOGIES（SHANGHAI）CO.,LTD
700000-7FFFFF     (base 16)		LUCISTECHNOLOGIES（SHANGHAI）CO.,LTD
				No.57.East Caohejing.Building Lucis XuHui District, Shanghai.200235.China
				SHANGHAI  SHANGHAI  200235
				CN

CC-1B-E0   (hex)		Earphone Connection, Ubc.
500000-5FFFFF     (base 16)		Earphone Connection, Ubc.
				25139 Ave Stanford
				Valnecia  CA  91355
				US

A0-3E-6B   (hex)		Nanjing zhanyi software technology co., LTD
E00000-EFFFFF     (base 16)		Nanjing zhanyi software technology co., LTD
				Room 1101-1,Building No.2,No.106 Software Avenue,Yuhuatai District,Nanjing Jiangsu
				Nanjing  Jiangsu  210000
				CN

A0-3E-6B   (hex)		Business Support Consultant Co.,Ltd
100000-1FFFFF     (base 16)		Business Support Consultant Co.,Ltd
				Room 703-705, 5 Guihua Road, Futian Free Trade Zone,  Shenzhen, China
				Shenzhen  Guangdong  518038
				CN

00-55-DA   (hex)		Novexx Solutions GmbH
300000-3FFFFF     (base 16)		Novexx Solutions GmbH
				Ohmstrasse 3
				Eching  Bayern  85386
				DE

DC-44-27   (hex)		Nautilus Infotech CO., Ltd.
B00000-BFFFFF     (base 16)		Nautilus Infotech CO., Ltd.
				No.55, Fengcheng St., Bade District, Taoyuan City 334, Taiwan(R.O.C)
				Taoyuan City  NA  334
				TW

DC-44-27   (hex)		Pyrexx Technologies GmbH
C00000-CFFFFF     (base 16)		Pyrexx Technologies GmbH
				Spichernstr. 2
				Berlin  Berlin  10777
				DE

DC-44-27   (hex)		Shanghai Huahong Integrated Circuit Co.,Ltd
A00000-AFFFFF     (base 16)		Shanghai Huahong Integrated Circuit Co.,Ltd
				No.39,Lane572,Bi Bo Road,Zhangjiang High-Tech Park,Shanghai
				Shanghai  Shanghai  201203
				CN

1C-21-D1   (hex)		Private
C00000-CFFFFF     (base 16)		Private

C8-8E-D1   (hex)		German Pipe GmbH
100000-1FFFFF     (base 16)		German Pipe GmbH
				Darrweg 43
				Nordhausen  Thuringia  D-99734
				DE

1C-21-D1   (hex)		Ognios GmbH
100000-1FFFFF     (base 16)		Ognios GmbH
				Dr.-Hans-Lechner-Straße 6
				Wals-Siezenheim  Salzburg  5071
				AT

B0-C5-CA   (hex)		D&T Inc.
900000-9FFFFF     (base 16)		D&T Inc.
				Gajungbukro 26-121
				YouSung Gu  Daejeon  305-343
				KR

DC-44-27   (hex)		Nex Technologies PTY LTD
400000-4FFFFF     (base 16)		Nex Technologies PTY LTD
				7 Pimpala Street
				Lithgow  New South Wales  2790
				AU

78-C2-C0   (hex)		Beijing Coilabs technology co.,ltd
800000-8FFFFF     (base 16)		Beijing Coilabs technology co.,ltd
				The 8th floor, Zhongguancun Dream Lab Building, No.1 Haidian Street, Haidian District, Beijing City, China
				Beijing  Beijing  100086
				CN

78-C2-C0   (hex)		Ombitron, Inc.
A00000-AFFFFF     (base 16)		Ombitron, Inc.
				1425 Broadway
				Seattle  Washington  98122
				US

78-C2-C0   (hex)		KORF Inc.
D00000-DFFFFF     (base 16)		KORF Inc.
				201, Radio Engineering Center
				Yuseong-gu  Daejeon  305-510
				KR

B4-37-D1   (hex)		Yireh Auto Tech Co.,Ltd.
600000-6FFFFF     (base 16)		Yireh Auto Tech Co.,Ltd.
				#703, 311 Nowon-ro, Nowon-gu
				Seoul  Seoul  139865
				KR

B4-37-D1   (hex)		Lezyne INC USA
000000-0FFFFF     (base 16)		Lezyne INC USA
				645 Tank Farm
				San Luis Obispo  California  93401
				US

78-C2-C0   (hex)		Guangzhou Hongcai Stage Equipment co.,ltd
700000-7FFFFF     (base 16)		Guangzhou Hongcai Stage Equipment co.,ltd
				no.32 Changsha Rd Shayong village
				Guangzhou  Guangdong  511450
				CN

B4-37-D1   (hex)		GE Power Management
700000-7FFFFF     (base 16)		GE Power Management
				Avenida Pinoa 10
				Zamudio  Vizcaya  48170
				ES

74-F8-DB   (hex)		WiFi Hotspots, SL
400000-4FFFFF     (base 16)		WiFi Hotspots, SL
				C/ Montaña Clara, No.18
				Fañabe  Tenerife  38760
				ES

74-F8-DB   (hex)		Shenzhen Ruishi Information Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Shenzhen Ruishi Information Technology Co.,Ltd.
				9G,Building A,Nanyuemingzhu Buliding,No.2322, Houhai Avenue,Nanshan District
				Shenzhen  Guangdong  518062
				CN

74-F8-DB   (hex)		Wuhan Tianyu Information Industry Co., Ltd.
700000-7FFFFF     (base 16)		Wuhan Tianyu Information Industry Co., Ltd.
				HUST Industry Park, East-Lake Development Zone
				Wuhan  Hubei  430223
				CN

54-9A-11   (hex)		Niveo International BV
700000-7FFFFF     (base 16)		Niveo International BV
				Communicatieweg 9-L
				Mijdrecht    3641 SG
				NL

54-9A-11   (hex)		Beijing HTSmartech Co.,Ltd
E00000-EFFFFF     (base 16)		Beijing HTSmartech Co.,Ltd
				Suite 301,Unit 2,Building 6,No.29,Jing Hai
				Beijing  Beijing  100176
				CN

54-9A-11   (hex)		eTauro LLC
400000-4FFFFF     (base 16)		eTauro LLC
				PMB 128
				Houston  TX  77044
				US

54-9A-11   (hex)		Royal Boon Edam International BV
300000-3FFFFF     (base 16)		Royal Boon Edam International BV
				PO box 40
				Edam  Noord Holland  1135 ZG
				NL

54-9A-11   (hex)		Shenzhen Excera Technology Co.,Ltd.
000000-0FFFFF     (base 16)		Shenzhen Excera Technology Co.,Ltd.
				4Th floor,Block A,,JunXiangDA Building,No.9 ZhongShan Park Road
				ShenZhen  Guangdong  518052
				CN

80-7B-85   (hex)		Interplan Co., Ltd.
A00000-AFFFFF     (base 16)		Interplan Co., Ltd.
				5F Ishihara Bld. 3-3-12 Iidabashi
				Chiyoda-ku  Tokyo  102-0072
				JP

64-FB-81   (hex)		Dongyang unitech.co.ltd
D00000-DFFFFF     (base 16)		Dongyang unitech.co.ltd
				8F dearung technotown 13
				seoul    153-803
				KR

64-FB-81   (hex)		Bridgeport Instruments, LLC
C00000-CFFFFF     (base 16)		Bridgeport Instruments, LLC
				11740 Jollyville Rd.
				Austin  TX  78759
				US

64-FB-81   (hex)		Seven Solutions S.L
200000-2FFFFF     (base 16)		Seven Solutions S.L
				C/Periodista Rafael Gómez Montero, 2.
				Granada  Granada  18014
				ES

64-FB-81   (hex)		ChengDu KeChuang LongXin Sci-tech Co.,Ltd
E00000-EFFFFF     (base 16)		ChengDu KeChuang LongXin Sci-tech Co.,Ltd
				12 South 1Section,First Ring Road
				ChengDu  Sichuan  610041
				CN

64-FB-81   (hex)		hiQview Corporation
900000-9FFFFF     (base 16)		hiQview Corporation
				2 Fl., No. 282, Sec. 6, Zhongxiao E. Rd.,
				Taipei    11558
				TW

80-7B-85   (hex)		Quickte Technology Co.,Ltd
600000-6FFFFF     (base 16)		Quickte Technology Co.,Ltd
				4thF/Bldg44, XiLiTong Long industrial Zone,
				Shenzhen  Guangdong province  518052
				CN

80-E4-DA   (hex)		Beijing Yuantel Technolgy Co.,Ltd-Shenzhen Branch
400000-4FFFFF     (base 16)		Beijing Yuantel Technolgy Co.,Ltd-Shenzhen Branch
				Room502,B  BLdg, Fuan mansion
				Shenzhen  Gangdong  518000
				CN

80-E4-DA   (hex)		Krizer international Co,. Ltd.
800000-8FFFFF     (base 16)		Krizer international Co,. Ltd.
				RM 9F, Block B, Central Building
				shenzhen  guangdong  518101
				CN

80-E4-DA   (hex)		Nanjing LILO Technology Co. Ltd.
B00000-BFFFFF     (base 16)		Nanjing LILO Technology Co. Ltd.
				YouLeHui Building E, 3011
				Beijing  Beijing  100000
				CN

80-E4-DA   (hex)		EVER Sp. z o.o.
C00000-CFFFFF     (base 16)		EVER Sp. z o.o.
				ul. Grudzinskiego 30
				Swarzedz  wielkopolskie  62-020
				PL

1C-CA-E3   (hex)		eSight Corporation
D00000-DFFFFF     (base 16)		eSight Corporation
				535 Legget Drive
				Ottawa  Ontario  K2K3B8
				CA

80-E4-DA   (hex)		Beijing Gaokezhongtian Technology Co Ltd
300000-3FFFFF     (base 16)		Beijing Gaokezhongtian Technology Co Ltd
				Beijing City Haidian District 23 Liangziyinzuo 806 room
				beijing  beijing  100191
				CN

1C-CA-E3   (hex)		Bird Home Automation GmbH
700000-7FFFFF     (base 16)		Bird Home Automation GmbH
				Joachimsthaler Str. 12
				Berlin  Berlin  10719
				DE

2C-D1-41   (hex)		XiaMen 35.com Technology Co,.Ltd.
700000-7FFFFF     (base 16)		XiaMen 35.com Technology Co,.Ltd.
				8th.building,Guanri Road,Software Park
				Xiamen  Fujian  361008
				CN

90-C6-82   (hex)		Cinet Inc
700000-7FFFFF     (base 16)		Cinet Inc
				8616 Phoenix Drive
				Manassas  VA  20110
				US

90-C6-82   (hex)		Innovative Electronic Technology
300000-3FFFFF     (base 16)		Innovative Electronic Technology
				IET House
				Potten End  Herts  HP42RN
				GB

90-C6-82   (hex)		Teletek Electronics
800000-8FFFFF     (base 16)		Teletek Electronics
				14A Srebarna Str.
				  Sofia  1407
				BG

90-C6-82   (hex)		Nanjing Jiexi Technologies Co., Ltd.
600000-6FFFFF     (base 16)		Nanjing Jiexi Technologies Co., Ltd.
				2ND FLOOR,BUILDING 9,JIANGSU SOFTWARE
				Nanjing  Jiangsu  210023
				CN

2C-6A-6F   (hex)		Shanghai Shuncom Electronic Technology Co.,Ltd
000000-0FFFFF     (base 16)		Shanghai Shuncom Electronic Technology Co.,Ltd
				8/F,No.4 building,No.3000 Longdong Ave,,
				shanghai  shanghai  201203
				CN

90-C6-82   (hex)		Shanghai HuRong Communication Technology Development Co., Ltd.
E00000-EFFFFF     (base 16)		Shanghai HuRong Communication Technology Development Co., Ltd.
				Room 342，Building A，No.68. Donghe Road, Chengqiao town, Chongming county（Chengqiao Economic Development Zone）
				shanghai  shanghai  202150
				CN

2C-6A-6F   (hex)		Wellntel, Inc.
A00000-AFFFFF     (base 16)		Wellntel, Inc.
				4230 N Oakland Ave, Suite 202
				Milwaukee  WI  53211
				US

2C-D1-41   (hex)		Bowei Technology Company Limited
600000-6FFFFF     (base 16)		Bowei Technology Company Limited
				Room 1716, Building Xinmao,
				  Shanghai  200233
				CN

28-FD-80   (hex)		Digital Signal Corp
400000-4FFFFF     (base 16)		Digital Signal Corp
				14000 Thunderbolt Place
				Chantilly  VA  20151
				US

A0-BB-3E   (hex)		Xiamen Kehua Hengsheng Co.,Ltd
600000-6FFFFF     (base 16)		Xiamen Kehua Hengsheng Co.,Ltd
				No.457,Malong Road,Torch High-tech Industrial Zone
				Xiamen  Fujian  361000
				CN

A0-BB-3E   (hex)		AutarcTech GmbH
800000-8FFFFF     (base 16)		AutarcTech GmbH
				Technologiepark 1
				Ansbach  Bavaria  91522
				DE

A0-BB-3E   (hex)		Sandal Plc
900000-9FFFFF     (base 16)		Sandal Plc
				Unit 5 Harold Close
				Harlow  Essex  
				GB

F8-02-78   (hex)		Innodisk
200000-2FFFFF     (base 16)		Innodisk
				5F., No.237, Sec. 1, Datong Rd., Xizhi Dist.,
				New Taipei City  Taiwan  221
				TW

F8-02-78   (hex)		Beijing Redcdn Technology, Co., Ltd
900000-9FFFFF     (base 16)		Beijing Redcdn Technology, Co., Ltd
				7F, B block, Yu Hui building
				Haidian District  Beijing  100142
				CN

2C-26-5F   (hex)		Motec GmbH
500000-5FFFFF     (base 16)		Motec GmbH
				Oberweyerer Strasse 21
				Hadamar-Steinbach  Hessen  65589
				DE

2C-26-5F   (hex)		Hysentel Technology Co., Ltd
E00000-EFFFFF     (base 16)		Hysentel Technology Co., Ltd
				Floor 2 Building L  No.26#  2 xiang
				Shenzhen  Guangdong  518101
				CN

A4-4F-29   (hex)		Comsel System Ltd
300000-3FFFFF     (base 16)		Comsel System Ltd
				Universitetsstranden 5
				Vasa    65200
				FI

0C-EF-AF   (hex)		Sentry360
400000-4FFFFF     (base 16)		Sentry360
				23807 W Andrew Road
				Plainfield  IL  60585
				US

3C-39-E7   (hex)		University of British Columbia
400000-4FFFFF     (base 16)		University of British Columbia
				Department of Civil Engineering
				Vancouver  BC  V6T 1Z4
				CA

3C-39-E7   (hex)		BEWATEC Kommunikationstechnik GmbH
100000-1FFFFF     (base 16)		BEWATEC Kommunikationstechnik GmbH
				Orkotten 65
				Telgte  NRW  48291
				DE

10-07-23   (hex)		RippleTek Tech Ltd
000000-0FFFFF     (base 16)		RippleTek Tech Ltd
				Tianyi Street #38 Idealisim Center Building #1 Room #705
				Chengdu  Sichuan  610041
				CN

B8-D8-12   (hex)		Lam Research
D00000-DFFFFF     (base 16)		Lam Research
				4305 cushing parkway
				Fremont  California  94538
				US

D0-22-12   (hex)		AIM
100000-1FFFFF     (base 16)		AIM
				21, avenue de la Plaine Fleurie
				MEYLAN  ISERE  38240
				FR

B8-D8-12   (hex)		Yuwei Info&Tech Development Co.,Ltd
C00000-CFFFFF     (base 16)		Yuwei Info&Tech Development Co.,Ltd
				Floor 6, Taike Building, No 2 Taike Road, Futian
				Shenzhen  Guangdong  518049
				CN

E8-18-63   (hex)		clabsys
100000-1FFFFF     (base 16)		clabsys
				9F Elentec-dong, Pangyo 7 Venture Valley II, 633
				Seongnam-si  Kyeonggi-do  463-010
				KR

E8-18-63   (hex)		Siliconcube
700000-7FFFFF     (base 16)		Siliconcube
				Room 702, KSIA Building, 182,
				Seongnam-si  Gyeonggi-do  463-400
				KR

D0-22-12   (hex)		Shenzhen SIC Technology. Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen SIC Technology. Co., Ltd.
				Room 601-31,Floor 6,Meinian International Square
				Shenzhen  Guangdong  518042
				CN

D0-22-12   (hex)		URANO INDUSTRIA DE BALANCAS E EQUIPAMENTOS LTDA
600000-6FFFFF     (base 16)		URANO INDUSTRIA DE BALANCAS E EQUIPAMENTOS LTDA
				RUA IRMAO PEDRO, 709
				CANOAS  RS  92020550
				BR

E8-18-63   (hex)		BSM Wireless Inc.
900000-9FFFFF     (base 16)		BSM Wireless Inc.
				75 International Blvd.
				Toronto  Ontario  M9W 6L9
				CA

D0-22-12   (hex)		RHENAC Systems GmbH
200000-2FFFFF     (base 16)		RHENAC Systems GmbH
				Christian-Lassen-Str. 16
				Bonn  NRW  53117
				DE

74-E1-4A   (hex)		emz-Hanauer GmbH & Co. KGaA
300000-3FFFFF     (base 16)		emz-Hanauer GmbH & Co. KGaA
				Siemensstrasse 1
				Nabburg  Bavaria  92507
				DE

74-E1-4A   (hex)		open joint stock company YUG-SISTEMA plus
400000-4FFFFF     (base 16)		open joint stock company YUG-SISTEMA plus
				
				Krasnodar   Krasnodar Region  350072
				RU

B8-D8-12   (hex)		VOTEM
100000-1FFFFF     (base 16)		VOTEM
				27, Geodudanji 1-gil,
				Chuncheon-Si  Gangwon-Do  200-883
				KR

B8-D8-12   (hex)		Vonger Electronic Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Vonger Electronic Technology Co.,Ltd.
				Qiaodong Street #24
				Taiyuan  Shanxi  030001
				CN

E4-95-6E   (hex)		NationalchipKorea
700000-7FFFFF     (base 16)		NationalchipKorea
				#1109, Ace PyeongchonTower
				Anyang-si  Gyeonggi-do  431-804
				KR

E4-95-6E   (hex)		Tacom Projetos Bilhetagem Inteligente ltda
E00000-EFFFFF     (base 16)		Tacom Projetos Bilhetagem Inteligente ltda
				3800 Raja Gabaglia avenue
				Belo Horizonte  Minas Gerais  30494310
				BR

E4-95-6E   (hex)		Shanghai DGE Co., Ltd
300000-3FFFFF     (base 16)		Shanghai DGE Co., Ltd
				No.6608, Beisong Road,
				  Shanghai  201611
				CN

E4-95-6E   (hex)		Guang Lian Zhi Tong Technology Limited
400000-4FFFFF     (base 16)		Guang Lian Zhi Tong Technology Limited
				Room 1102 Baoyuanhuafeng Economy Bldg
				Shenzhen  Guang Dong  518000
				

BC-66-41   (hex)		Shenzhen Yaguang communication CO.,LTD
800000-8FFFFF     (base 16)		Shenzhen Yaguang communication CO.,LTD
				7 Floor,3 building,Guangqian community ,Bagua Load
				Shenzhen  Guangdong  518029
				CN

BC-66-41   (hex)		EBlink
A00000-AFFFFF     (base 16)		EBlink
				3-5 Rue Marcel Pagnol
				Boussy Saint Antoine  France  91800
				FR

58-FC-DB   (hex)		Applied Device Technologies
E00000-EFFFFF     (base 16)		Applied Device Technologies
				400 West Front Street
				Traverse City  Michigan  49684
				US

58-FC-DB   (hex)		XIAMEN LEELEN TECHNOLOGY CO.,LTD
D00000-DFFFFF     (base 16)		XIAMEN LEELEN TECHNOLOGY CO.,LTD
				65 Sunban South Rd.
				Xiamen  Fujian  361021
				CN

BC-66-41   (hex)		Process-Electronic Sp. z o.o.
200000-2FFFFF     (base 16)		Process-Electronic Sp. z o.o.
				ul. Jednosci 48
				Sosnowiec  slaskie  41-218
				PL

58-FC-DB   (hex)		Beseye Cloud Security Co. Ltd.
200000-2FFFFF     (base 16)		Beseye Cloud Security Co. Ltd.
				3F.-1, No.45-1, Dexing W. Rd., Shilin Dist.
				Taipei City  Taiwan  11158
				TW

B0-1F-81   (hex)		SHENZHEN YIFANG DIGITAL TECHNOLOGY CO.,LTD.
400000-4FFFFF     (base 16)		SHENZHEN YIFANG DIGITAL TECHNOLOGY CO.,LTD.
				Building NO.22,23, Fifth Region, Baiwangxin Industrial Park, Songbai Rd., Nanshan
				Shenzhen  Guangdong  518108
				CN

F4-0E-11   (hex)		Sterna Security
900000-9FFFFF     (base 16)		Sterna Security
				100 West Sambandam road
				Coimbatore  Tamilnadu  641002
				IN

B0-1F-81   (hex)		Rademacher Geraete-Elektronik GmbH
B00000-BFFFFF     (base 16)		Rademacher Geraete-Elektronik GmbH
				Buschkamp 7
				Rhede  NRW  46414
				DE

14-1F-BA   (hex)		Newings Communication CO., LTD.
B00000-BFFFFF     (base 16)		Newings Communication CO., LTD.
				12F, Block 1, NO 7866, Humin Rd, Minhang District, Shanghai, China
				Shanghai  Shanghai  200000
				CN

F4-0E-11   (hex)		realphone technology co.,ltd
000000-0FFFFF     (base 16)		realphone technology co.,ltd
				room 1207,block b, haisong building,tairan9th road park,futian district,shenzhen,china
				shenzhen  guangdong  518400
				CN

F4-0E-11   (hex)		Axel srl
200000-2FFFFF     (base 16)		Axel srl
				Via del Santo, 143
				Limena  PD  35010
				IT

7C-70-BC   (hex)		Tohan　Engineering　Corporation
B00000-BFFFFF     (base 16)		Tohan　Engineering　Corporation
				1-701-1 Baba
				Sennan-shi  Osaka  590-0525
				JP

14-1F-BA   (hex)		Private
300000-3FFFFF     (base 16)		Private

BC-34-00   (hex)		AURALIC LIMITED
A00000-AFFFFF     (base 16)		AURALIC LIMITED
				Room 102, Building No.7
				Beijing    102200
				CN

A4-3B-FA   (hex)		SHEN ZHEN PASUN TECH CO.LTD.
900000-9FFFFF     (base 16)		SHEN ZHEN PASUN TECH CO.LTD.
				Room B406, Taojindi E-Business Incubator Base
				SHENZHEN  GUANGDONG  518131
				CN

BC-34-00   (hex)		Cameron
600000-6FFFFF     (base 16)		Cameron
				14450 John F. Kennedy Blvd
				Houston  TX  77032
				

7C-70-BC   (hex)		FLEXIM GmbH
300000-3FFFFF     (base 16)		FLEXIM GmbH
				Wolfener Strasse 36
				  BERLIN  12681
				DE

D0-76-50   (hex)		CentrAlert, Inc.
000000-0FFFFF     (base 16)		CentrAlert, Inc.
				275 Meijer Way
				Lexington  KY  40503
				US

A4-3B-FA   (hex)		Circus World Displays Ltd
300000-3FFFFF     (base 16)		Circus World Displays Ltd
				4080 Montrose Rd
				Niagara Falls  Ontario  L2H 1J9
				CA

A4-3B-FA   (hex)		Beijing Uniwill Science and Technology Co,Ltd
100000-1FFFFF     (base 16)		Beijing Uniwill Science and Technology Co,Ltd
				NO.30 Jinyuan Road Daxing Zone
				  Beijing  102600
				CN

A4-3B-FA   (hex)		Chengdu Territory Technology Co.,Ltd
000000-0FFFFF     (base 16)		Chengdu Territory Technology Co.,Ltd
				Flat 23, #4, Senhua Gargden Shaoling Road
				Chengdu  Sichuan  610000
				CN

D0-76-50   (hex)		tecnotron elekronik gmbh
D00000-DFFFFF     (base 16)		tecnotron elekronik gmbh
				Wildberg 64
				Weissensberg  Bavaria  88138
				DE

D0-76-50   (hex)		Greenwave Scientific
900000-9FFFFF     (base 16)		Greenwave Scientific
				2720 Discovery Dr.
				Raleigh  North Carolina  27612
				US

74-19-F8   (hex)		IDEXX Laboratories, Inc
B00000-BFFFFF     (base 16)		IDEXX Laboratories, Inc
				1 IDEXX Drive
				Westbrook  ME  04092
				US

74-19-F8   (hex)		Heptagon Systems PTY. LTD.
700000-7FFFFF     (base 16)		Heptagon Systems PTY. LTD.
				625-627 Ringwood Warrandyte Road
				Ringwood North  VIC  3124
				AU

74-19-F8   (hex)		Bach Icon ApS
C00000-CFFFFF     (base 16)		Bach Icon ApS
				Ambolten 8
				Hoersholm  DK  2970
				DK

4C-4B-F9   (hex)		Beijing AutoAi Technology co. LTD
E00000-EFFFFF     (base 16)		Beijing AutoAi Technology co. LTD
				The building of Navinfo ,at the intersection Yongfeng road and Beiqing road,Haidian District
				Beijing  Beijing  100094
				CN

40-11-75   (hex)		Kanda Kogyo
200000-2FFFFF     (base 16)		Kanda Kogyo
				3-6 Kandacho
				HImeji  Hyogo  6700991
				JP

40-11-75   (hex)		Beijing Gemotech Intelligent Technology Co., Ltd.
800000-8FFFFF     (base 16)		Beijing Gemotech Intelligent Technology Co., Ltd.
				NO.1 Development Road,Beijing International Information Industrial Base,Huilongguan Town,Changping District
				Beijing  Beijing  102206
				CN

40-11-75   (hex)		ADH Guardian USA
900000-9FFFFF     (base 16)		ADH Guardian USA
				122 Penn St
				El Segundo  CA  90245
				US

04-D1-6E   (hex)		ShenZhen Huafu Information technology Co.?Ltd
400000-4FFFFF     (base 16)		ShenZhen Huafu Information technology Co.?Ltd
				T2-B5 FLOOR, shenzhen software park, gaoxin south 7th road, yuehai                street, nanshan district
				ShenZhen  GuangDong  518000
				CN

24-4E-7B   (hex)		Church & Dwight Co., Inc.
D00000-DFFFFF     (base 16)		Church & Dwight Co., Inc.
				500 Charles Ewing Blvd
				Ewing  NJ  08628
				US

04-D1-6E   (hex)		CHENGDU INTERLINK SCIENCE AND TECHNOLOGY CO.,LTD
800000-8FFFFF     (base 16)		CHENGDU INTERLINK SCIENCE AND TECHNOLOGY CO.,LTD
				Room 1305, 12A Level, Wanke Huamao Building
				Sichuan  Chengdu  610051
				CN

04-D1-6E   (hex)		PacPort Corporation
C00000-CFFFFF     (base 16)		PacPort Corporation
				Ginza 6-10-1, GINZA SIX 13F, Chuo-ku
				Tokyo  Tokyo  1040061
				JP

04-D1-6E   (hex)		Launch Tech Co., Ltd.
100000-1FFFFF     (base 16)		Launch Tech Co., Ltd.
				Launch Industrial Park, No.4012, North of Wuhe Road, Bantian Street, Longgang District,
				Shenzhen  Guangdong  518100
				CN

04-D1-6E   (hex)		Envision Energy
700000-7FFFFF     (base 16)		Envision Energy
				8/F, Building B, SOHO Zhongshan Plaza, 1065 West Zhongshan Road
				Shanghai     200051
				CN

44-03-77   (hex)		Hangzhou Asia Infrastructure Tech. Co., Ltd.
B00000-BFFFFF     (base 16)		Hangzhou Asia Infrastructure Tech. Co., Ltd.
				No.7 Xiyuan Rd, Sandun Town, Westlake District
				Hangzhou  Zhejiang  310000
				CN

44-03-77   (hex)		Stara S/A Indústria de Implementos Agrícolas
700000-7FFFFF     (base 16)		Stara S/A Indústria de Implementos Agrícolas
				Avenida Stara 519
				Não-Me-Toque  Rio Grande do Sul  99470000
				BR

50-62-55   (hex)		AVTECH Software, Inc.
700000-7FFFFF     (base 16)		AVTECH Software, Inc.
				16 Cutler Str, Cutler Mill
				Warren  RI  02885
				US

50-62-55   (hex)		Hypertech Advance Co., LTD
300000-3FFFFF     (base 16)		Hypertech Advance Co., LTD
				1F., No. 9, Changchun 6th Rd., Zhongli Dist.,
				 Taoyuan City    320
				TW

50-62-55   (hex)		Suzhou Ruixinjie Information Technology Co.,Ltd
500000-5FFFFF     (base 16)		Suzhou Ruixinjie Information Technology Co.,Ltd
				Room 907,No. 99 Changli Road
				Suzhou  Jiangsu  215000
				CN

64-31-39   (hex)		Hunan Voc Acoustics Technology Co., Ltd.
600000-6FFFFF     (base 16)		Hunan Voc Acoustics Technology Co., Ltd.
				State Industrialpark, Jiulong Development Zone, Yanling County
				Zhuzhou  Hunan  412500
				CN

50-62-55   (hex)		AED Distribution
C00000-CFFFFF     (base 16)		AED Distribution
				Bedrijvenpark De Veert 13/004
				Willebroek    2830
				BE

64-31-39   (hex)		KOANGYOW INTEGRATION MACHINE CO., LTD.
300000-3FFFFF     (base 16)		KOANGYOW INTEGRATION MACHINE CO., LTD.
				7F., No. 566, Zhongzheng Rd., Xindian Dist.
				New Taipei City    23148
				TW

64-31-39   (hex)		SHEN ZHEN FUCHANG TECHNOLOGY Co.,Ltd.
C00000-CFFFFF     (base 16)		SHEN ZHEN FUCHANG TECHNOLOGY Co.,Ltd.
				Floor 4 11 Building Qixing Factory,Niu Cheng 2rd Industrial Area,Xili Nanshan District
				Shenzhen  GUANGDONG  518055
				CN

C4-95-4D   (hex)		SolidGear Corporation
C00000-CFFFFF     (base 16)		SolidGear Corporation
				Shinyokohama Kaneko Bldg 8F, 2-3-9 ShinYokohama Kohoku-ku
				Yokohama  Knanagawa  222-0033
				JP

C4-95-4D   (hex)		Sercomm Corporation.
300000-3FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

00-69-67   (hex)		Hangzhou Wise IOT Technology Co.,Ltd
900000-9FFFFF     (base 16)		Hangzhou Wise IOT Technology Co.,Ltd
				Room 405, Building 2, No. 31, Science and Technology Avenue, Yuhang Street, Yuhang District
				Hangzhou  Zhejiang  310012
				CN

64-31-39   (hex)		Active Brains
400000-4FFFFF     (base 16)		Active Brains
				Yokohama Dia BLDG 8F 1-7 Kinkocho Kanagawa-ku
				Yokohama  Kanagawa  221-0056
				JP

00-69-67   (hex)		Ambient-System sp. z o.o.
800000-8FFFFF     (base 16)		Ambient-System sp. z o.o.
				ul. Galaktyczna 37
				Gdansk    80-299
				PL

00-69-67   (hex)		Datapan d.o.o.
B00000-BFFFFF     (base 16)		Datapan d.o.o.
				Velika Pot 19
				Solkan    5250
				SI

00-69-67   (hex)		Tianjin Lianwu Technology Co., Ltd. 
E00000-EFFFFF     (base 16)		Tianjin Lianwu Technology Co., Ltd. 
				Room 201, 2nd floor, Building 8, No.35, Caizhi Street, Xuefu Industrial Zone, Xiqing District
				Tianjin  Tianjin  300380
				CN

A0-22-4E   (hex)		IST ElektronikgesmbH
A00000-AFFFFF     (base 16)		IST ElektronikgesmbH
				Marktplatz 40
				Neukirchen am Walde  Upper Austria  4724
				AT

A0-22-4E   (hex)		rNET Controls 
100000-1FFFFF     (base 16)		rNET Controls 
				8231 SW Cirrus Dr
				Beaverton  OR  97008
				US

20-0A-0D   (hex)		Tecnint HTE SRL
700000-7FFFFF     (base 16)		Tecnint HTE SRL
				Via della Tecnica 16/18
				Osnago  Lecco  23875
				IT

20-0A-0D   (hex)		IRSAP
A00000-AFFFFF     (base 16)		IRSAP
				Via delle Industrie, 211
				Arqua' Polesine  Veneto  45031
				IT

40-2C-76   (hex)		Annapurna labs
200000-2FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

40-2C-76   (hex)		Baumer Bourdon-Haenni
500000-5FFFFF     (base 16)		Baumer Bourdon-Haenni
				125 Rue de la marre
				Vendôme    41100
				FR

40-2C-76   (hex)		NowTechnologies Zrt
A00000-AFFFFF     (base 16)		NowTechnologies Zrt
				18 Realtanoda
				Budapest    1053
				HU

50-DE-19   (hex)		Shenzhen Vipstech Co., Ltd
C00000-CFFFFF     (base 16)		Shenzhen Vipstech Co., Ltd
				Building 10th, Baiwangxin Industrial Park, No. 1002 Songbai Road, Xili Street, 
				Shenzhen  Guangdong  518100
				CN

50-DE-19   (hex)		Telic AG
000000-0FFFFF     (base 16)		Telic AG
				Raiffeisenallee 12b
				Oberhaching    82041
				DE

3C-FA-D3   (hex)		Shenzhen zhong ju  Fiber optical Co.Ltd
C00000-CFFFFF     (base 16)		Shenzhen zhong ju  Fiber optical Co.Ltd
				3t Floor Build A .jin he Rui park .guan lan.
				Shen zhen  Guang dong  518000
				CN

3C-FA-D3   (hex)		Naruida Technology Ltd.
200000-2FFFFF     (base 16)		Naruida Technology Ltd.
				2 Gangle Road,Tangjia Bay Town, High Tech Zone
				Zhuhai  Guangdong  519080
				CN

90-E2-FC   (hex)		Huddly AS
900000-9FFFFF     (base 16)		Huddly AS
				Karenslyst Allé 51
				Oslo    0279
				NO

90-E2-FC   (hex)		Shenzhen Dingsheng Intelligent Technology Co., Ltd
B00000-BFFFFF     (base 16)		Shenzhen Dingsheng Intelligent Technology Co., Ltd
				10/F Block C, Skyworth Building, Gaoxin South 1st Rd., Hi-Tech Park, Nanshan District
				Shenzhen  Guangdong  518000
				CN

14-AE-85   (hex)		Veo Technologies
900000-9FFFFF     (base 16)		Veo Technologies
				Aldersrogade 6c, 4. sal
				København  Denmark  2100
				DK

14-AE-85   (hex)		SHENZHEN HONOR ELECTRONIC CO.,LTD
700000-7FFFFF     (base 16)		SHENZHEN HONOR ELECTRONIC CO.,LTD
				No. A Building, Xinghui Industrial Park, Gushu No. 2Rd,
				SHEN ZHEN  GUANG  DONG  518000
				CN

94-CC-04   (hex)		Shenzhen Link technology Co.,Ltd
300000-3FFFFF     (base 16)		Shenzhen Link technology Co.,Ltd
				901,9/F,Dahong High TechIndusryPark?NO.6-18,Xinhe Road,Xinqiao Community,Baoan District
				Shenzhen  Guangdong  518000
				CN

94-CC-04   (hex)		SHENZHEN SANRAY TECHNOLOGY CO.,LTD
500000-5FFFFF     (base 16)		SHENZHEN SANRAY TECHNOLOGY CO.,LTD
				1B08 2/F Folk Culture Industrial Park,Qunli Second Road, Baoan District
				Shenzhen  GuangDong  518101
				CN

94-CC-04   (hex)		GOCOAX, INC
100000-1FFFFF     (base 16)		GOCOAX, INC
				15902A Halliburton Rd #662 
				Hacienda Heights  CA  91745
				US

94-05-BB   (hex)		Chengdu Zhongheng Network Co.,Ltd.
500000-5FFFFF     (base 16)		Chengdu Zhongheng Network Co.,Ltd.
				No.898 Baicao Road, Chengdu High-tech Zone (Western District)
				Chengdu  Sichuan  611731
				CN

94-CC-04   (hex)		Shanxi Baixin Information Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Shanxi Baixin Information Technology Co., Ltd.
				Room 210-213, Room 215-217, Room 219-220, No.2, Yari Street, Taiyuan University Park, Shanxi Comprehensive Reform Demonstration Zone
				Taiyuan  Shanxi  030032
				CN

D0-C8-57   (hex)		IFLYTEK CO.,LTD.
D00000-DFFFFF     (base 16)		IFLYTEK CO.,LTD.
				National Intelligent Speech High-tech Industrialization Base, No. 666, Wangjiang Road West,
				Hefei  An hui  230088
				CN

94-05-BB   (hex)		ZIGPOS GmbH
600000-6FFFFF     (base 16)		ZIGPOS GmbH
				Räcknitzhöhe 35a
				Dresden  Saxony  01217
				DE

94-05-BB   (hex)		SolarEdge Technologies
A00000-AFFFFF     (base 16)		SolarEdge Technologies
				1 Abba Eban St.
				Herzelia    46725
				IL

F4-90-CB   (hex)		Airbeam Wireless Technologies Inc.
600000-6FFFFF     (base 16)		Airbeam Wireless Technologies Inc.
				#125, 21320 Gordon Way
				Richmond  British Columbia  V6W 1J8
				CA

C0-9B-F4   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

C0-9B-F4   (hex)		Alcatraz AI Inc.
900000-9FFFFF     (base 16)		Alcatraz AI Inc.
				1808 El Camino Real
				Redwood City  CA  94063
				US

F4-90-CB   (hex)		RSAE Labs Inc
E00000-EFFFFF     (base 16)		RSAE Labs Inc
				400 E 16th St
				Panama City  FL  32405
				US

C0-9B-F4   (hex)		Big Dutchman International GmbH
700000-7FFFFF     (base 16)		Big Dutchman International GmbH
				Auf der Lage, 2
				Vechta  Niedersachsen  49377
				DE

C0-9B-F4   (hex)		Continental Automotive Component Malaysia Sdn.Bhd.
E00000-EFFFFF     (base 16)		Continental Automotive Component Malaysia Sdn.Bhd.
				2455, MK.1, Tingkat Perusahaan 2A,
				Prai Industrial Estate, Prai,  Penang  13600
				MY

E8-B4-70   (hex)		Anduril Industries
C00000-CFFFFF     (base 16)		Anduril Industries
				2272 Michelson Dr
				Irvine  CA  92612
				US

E8-B4-70   (hex)		Webfleet Solutions B.V.
300000-3FFFFF     (base 16)		Webfleet Solutions B.V.
				De Ruijterkade 154
				Amsterdam    1011 AC
				NL

E8-B4-70   (hex)		Medica Corporation
D00000-DFFFFF     (base 16)		Medica Corporation
				 5 Oak Park Drive
				Bedford  MA  01730
				US

94-FB-A7   (hex)		Shenzhen Golden Star Technology Ltd
B00000-BFFFFF     (base 16)		Shenzhen Golden Star Technology Ltd
				Rm.622,building B,MingYou Industrial products Exhibition&Procurement center, Baoyuan Road,Xixiang,Bao’an District,
				Shenzhen  Guangdong  518000
				CN

94-FB-A7   (hex)		GUANG DONG TAKSTAR ELECTRONIC CO.,LTD.
300000-3FFFFF     (base 16)		GUANG DONG TAKSTAR ELECTRONIC CO.,LTD.
				Dinggang,Group 5, Xialiao Village,Longxi Town, Boluo County
				Huizhou City  Guangdong  516121
				CN

94-FB-A7   (hex)		Solaborate Inc.
C00000-CFFFFF     (base 16)		Solaborate Inc.
				#283 - 8300 Utica Ave
				Rancho Cucamonga  CA  91730
				US

94-FB-A7   (hex)		Sercomm Corporation.
600000-6FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

94-FB-A7   (hex)		CAVITY EYE
500000-5FFFFF     (base 16)		CAVITY EYE
				Ébner György köz 4.
				Budaörs    2040
				HU

94-FB-A7   (hex)		Anvil Systems Group, Inc.
700000-7FFFFF     (base 16)		Anvil Systems Group, Inc.
				8211 Terminal Road, Suite 1900
				Lorton   VA  22079
				US

38-F7-CD   (hex)		NZIA Connect Inc
100000-1FFFFF     (base 16)		NZIA Connect Inc
				1109 ho, Bupyeong tech city Bld, 293 Bupyeong-daero, Bupyeong-gu
				Incheon    21315
				KR

38-F7-CD   (hex)		Distech Controls
A00000-AFFFFF     (base 16)		Distech Controls
				4205 place de Java
				Brossard  QC  J4Y 0C4
				CA

70-69-79   (hex)		Graphcore Ltd
200000-2FFFFF     (base 16)		Graphcore Ltd
				11-19 Wine Street
				Bristol    BS1 2PH
				GB

CC-C2-61   (hex)		Ability Enterprise Co., Ltd
700000-7FFFFF     (base 16)		Ability Enterprise Co., Ltd
				No. 200, Sec. 3, Zhonghuan Rd., Xinzhuang Dist., New Taipei City 24242, Taiwan (R.O.C.)
				Taipei    24242
				TW

CC-C2-61   (hex)		EDAG Engineering GmbH
400000-4FFFFF     (base 16)		EDAG Engineering GmbH
				Dr.- Ludwig-Kraus-Str. 2
				Gaimersheim  Bavaria  85080
				DE

70-69-79   (hex)		Hebei Baina Xinda Technology Co., Ltd.
300000-3FFFFF     (base 16)		Hebei Baina Xinda Technology Co., Ltd.
				Building C, e-commerce Industrial Park, Xianghe robot Town
				Langfang City  Hebei Province  065400
				CN

F0-D7-AF   (hex)		Dongguan Gedi Electrons Techeology Co.,LTD
D00000-DFFFFF     (base 16)		Dongguan Gedi Electrons Techeology Co.,LTD
				Dongguan Gedi Electrons Techeology Co.,LTD
				Dongguan  Guangdong  523000
				CN

F0-D7-AF   (hex)		ID Tech Japan Co.,Ltd.
000000-0FFFFF     (base 16)		ID Tech Japan Co.,Ltd.
				Matsumura BLDG, 2-2-23,Shibazaki-cho, Tachikawa-shi
				Tokyo  Japan  1900023
				JP

F0-D7-AF   (hex)		Beijing Serviatech lnformation Tech Co.,Ltd
100000-1FFFFF     (base 16)		Beijing Serviatech lnformation Tech Co.,Ltd
				Floor?Building17 NO.1A?Chaoqian Rd?Changping?Beijing
				Beijing    102200
				CN

F0-D7-AF   (hex)		Wren Associates, LTD
E00000-EFFFFF     (base 16)		Wren Associates, LTD
				124 Wren Parkway
				Jefferson City  MO  65109-6332
				US

30-49-50   (hex)		HANGZHOU EV-TECH CO.,LTD
B00000-BFFFFF     (base 16)		HANGZHOU EV-TECH CO.,LTD
				No. 205, Zhenzhong Road, Xihu District
				HANGZHOU  ZHEJIANG  310012
				CN

30-49-50   (hex)		Curb, Inc.
600000-6FFFFF     (base 16)		Curb, Inc.
				1524 S IH35, Suite 345, Apt 134
				Austin  TX  78704
				US

30-49-50   (hex)		Shanghai gatang technology CO.,LTD
900000-9FFFFF     (base 16)		Shanghai gatang technology CO.,LTD
				Room 507, building 1, No. 2071, Hongmei Road, Xuhui District, 
				Shanghai    200030
				CN

5C-85-7E   (hex)		Annapurna labs
C00000-CFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

5C-85-7E   (hex)		mobilogix HongKong
200000-2FFFFF     (base 16)		mobilogix HongKong
				Limited Flat/RM 705A, 7/F, New East Ocean Centre No. 9 Science Museum Road Kowloon
				Hong Kong    000000
				CN

F4-69-D5   (hex)		Terminus (Shanghai) Technology Co.,Ltd.
900000-9FFFFF     (base 16)		Terminus (Shanghai) Technology Co.,Ltd.
				17F,building 2,CES west bund center,No.277 longlan road,xuhui,district
				Shanghai    200232
				CN

4C-93-A6   (hex)		Vestaboard, Inc.
000000-0FFFFF     (base 16)		Vestaboard, Inc.
				1777 Yosemite Avenue STE 220
				San Francisco  CA  94124
				US

4C-93-A6   (hex)		Sercomm Corporation.
800000-8FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

4C-93-A6   (hex)		Shandong Senter Electronic Co., Ltd
600000-6FFFFF     (base 16)		Shandong Senter Electronic Co., Ltd
				No. 18 Liuyishan Road, New&High-tech area
				Zibo  Shandong  255086
				CN

4C-93-A6   (hex)		5Voxel Co., Ltd.
700000-7FFFFF     (base 16)		5Voxel Co., Ltd.
				6F-2, No.273, Nong-an St.
				Taipei City    10482
				TW

4C-93-A6   (hex)		CELLTRON
E00000-EFFFFF     (base 16)		CELLTRON
				#601 L&C TOWER, 153-18 LS-ro,Sanbon
				Gunpo  Gyeonggi  15808
				KR

28-B7-7C   (hex)		Zhuhai RongBang Electronic Technology Co., Ltd.
200000-2FFFFF     (base 16)		Zhuhai RongBang Electronic Technology Co., Ltd.
				Room 110-400(central office) , building 18, Creative Valley, 1889 Huandao East road, Hengqin New District,
				Zhuhai  GuangDong  519000
				CN

28-B7-7C   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

28-B7-7C   (hex)		Convertertec Deutschland GmbH
700000-7FFFFF     (base 16)		Convertertec Deutschland GmbH
				Krefelder Weg 47
				Kempen    47906
				DE

C0-61-9A   (hex)		Nanjing SinoVatio Technology Co., Ltd
800000-8FFFFF     (base 16)		Nanjing SinoVatio Technology Co., Ltd
				No. 888 Zhengfang Middle Rd, Jiangning District
				Nanjing  JiangSu  211153
				CN

C0-61-9A   (hex)		Wingtech Mobile Communications  Co.,Ltd.
900000-9FFFFF     (base 16)		Wingtech Mobile Communications  Co.,Ltd.
				No.777,Yazhong Road,Nanhu District
				Jiaxing  Zhejiang  314001
				CN

C0-61-9A   (hex)		Gronn Kontakt AS
A00000-AFFFFF     (base 16)		Gronn Kontakt AS
				Kjøita 18
				Kristiansand    4630
				NO

98-FC-84   (hex)		Juketek Co., Ltd.
200000-2FFFFF     (base 16)		Juketek Co., Ltd.
				18F-6, No. 75, Sec. 1, Xintai 5th Rd., Xizhi Dist., 
				New Taipei City    221
				TW

18-FD-CB   (hex)		CISTECH Solutions
800000-8FFFFF     (base 16)		CISTECH Solutions
				170 JAMES ST
				TOOWOOMBA  QLD  4350
				AU

18-FD-CB   (hex)		SOTHIS CIC TEC (Shanghai) Co., Ltd
100000-1FFFFF     (base 16)		SOTHIS CIC TEC (Shanghai) Co., Ltd
				Shanghai Jiading sichenglu1250-7
				SHANGHAI  SHANGHAI  200000
				CN

18-FD-CB   (hex)		Sercomm Corporation.
A00000-AFFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

98-FC-84   (hex)		Shield Inc.
A00000-AFFFFF     (base 16)		Shield Inc.
				8F-5, No.57, Sec.1, Dunhua S. Rd., Songshan Dist.,
				Taipei City    10557
				TW

58-20-8A   (hex)		Shangyin Intelligence Technology Shandong Co.,Ltd
600000-6FFFFF     (base 16)		Shangyin Intelligence Technology Shandong Co.,Ltd
				2205,Building 2,Sanqingqisheng Square,No.1666,Xinluo Street
				Jinan  Shandong  250014
				CN

58-20-8A   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

58-20-8A   (hex)		TRING
400000-4FFFFF     (base 16)		TRING
				Lejlekusa bb
				Gracanica  TK  75320
				BA

58-20-8A   (hex)		Suzhou Ruilisi Technology Ltd.
900000-9FFFFF     (base 16)		Suzhou Ruilisi Technology Ltd.
				Gaoqingchuanmei Building, Nantiancheng Road, Xiangcheng District
				Suzhou  Jiangsu  215000
				CN

58-20-8A   (hex)		UPM Technology, Inc
E00000-EFFFFF     (base 16)		UPM Technology, Inc
				3000 NE Stucki ave ste #100
				Hillsboro    97124
				US

CC-4F-5C   (hex)		Kymati GmbH
500000-5FFFFF     (base 16)		Kymati GmbH
				Am Hochacker 5
				Grasbrunn    85630
				DE

FC-CD-2F   (hex)		Loupedeck Oy
200000-2FFFFF     (base 16)		Loupedeck Oy
				Museokatu 8 A 6
				Helsinki     00100
				FI

FC-CD-2F   (hex)		Aroma Retail
900000-9FFFFF     (base 16)		Aroma Retail
				5525 S. Valley View Blvd, ste 2
				Las Vegas  NV  89118
				US

58-95-D8   (hex)		Sercomm Corporation.
200000-2FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

DC-4A-9E   (hex)		LEACH INTERNATIONAL EUROPE
300000-3FFFFF     (base 16)		LEACH INTERNATIONAL EUROPE
				2 RUE GOETHE
				SARRALBE  MOSELLE  57430
				FR

DC-4A-9E   (hex)		 LongSung Technology (Shanghai) Co.,Ltd.   
A00000-AFFFFF     (base 16)		 LongSung Technology (Shanghai) Co.,Ltd.   
				 Room 606, Block B, Bldg. 1, No. 3000 Longdong Avenue., Zhangjiang Hi-Tech Park, Pudong District
				ShangHai    201203
				CN

DC-4A-9E   (hex)		Nuove Tecnologie srl
500000-5FFFFF     (base 16)		Nuove Tecnologie srl
				VIALE RIMEMBRANZE 47/B, VAT N° IT10907840150
				Lainate  Milan  20045
				IT

DC-4A-9E   (hex)		AiSight GmbH
900000-9FFFFF     (base 16)		AiSight GmbH
				Gertraudenstr 10-12
				Berlin    10178
				DE

84-11-C2   (hex)		Leybold GmbH
800000-8FFFFF     (base 16)		Leybold GmbH
				Bonnerstr. 498
				Cologne     50968
				DE

68-79-12   (hex)		LEAPS s.r.o.
900000-9FFFFF     (base 16)		LEAPS s.r.o.
				Na rolich 655/8
				Praha 4  Czech  141 00
				CZ

68-79-12   (hex)		Globus Infocom Limited
C00000-CFFFFF     (base 16)		Globus Infocom Limited
				A 65, Sector 4, Noida
				Noida  U P  201301
				IN

68-79-12   (hex)		Babbit and Friends, SIA
700000-7FFFFF     (base 16)		Babbit and Friends, SIA
				Maiznicas iela 8 - 5
				Riga  Riga  LV1001
				LV

68-79-12   (hex)		Ametek Solidstate Controls
E00000-EFFFFF     (base 16)		Ametek Solidstate Controls
				875 DEARBORN DR
				COLUMBUS  OH  43085-1586
				US

24-15-10   (hex)		Private
800000-8FFFFF     (base 16)		Private
				
				    
				

34-04-9E   (hex)		Church & Dwight Co., Inc.
900000-9FFFFF     (base 16)		Church & Dwight Co., Inc.
				500 Charles Ewing Blvd
				Ewing  NJ  08628
				US

8C-47-6E   (hex)		AU Optronics Corporation
A00000-AFFFFF     (base 16)		AU Optronics Corporation
				No. 1 Li-Hsin Rd. 2, Hsinchu Science Park
				Hsinchu 30078, Taiwan, R.O.C.    802
				TW

8C-47-6E   (hex)		IntelliVIX Co. Ltd.
800000-8FFFFF     (base 16)		IntelliVIX Co. Ltd.
				4, Hyoryeong-ro 34-gil, Seocho-gu
				Seoul    06704
				KR

8C-AE-49   (hex)		H3 Platform
100000-1FFFFF     (base 16)		H3 Platform
				11F-1, No. 79, Sec. 1, Xingtai 5th rd., Xizhi
				New Taipei    221
				TW

A4-53-EE   (hex)		MAHLE ELECTRONICS, SLU
000000-0FFFFF     (base 16)		MAHLE ELECTRONICS, SLU
				Ctra. Madrid-Valencia Km. 196
				Motilla del Palancar  Cuenca  16200
				ES

A4-53-EE   (hex)		SSK CORPORATION
D00000-DFFFFF     (base 16)		SSK CORPORATION
				3F, M-10, Centre of Hi-Tech Industrial Park, Nanshan
				Shenzhen    518054
				CN

A0-02-4A   (hex)		Argos Solutions AS
400000-4FFFFF     (base 16)		Argos Solutions AS
				Dyrmyrgata 35
				Kongsberg    3611
				NO

A0-02-4A   (hex)		Danriver Technologies Corp.
200000-2FFFFF     (base 16)		Danriver Technologies Corp.
				Building 3#,  2F, Yunxin Rd. 
				Shanghai    200436
				CN

A0-02-4A   (hex)		Kontakt Micro-Location Sp z o.o.
900000-9FFFFF     (base 16)		Kontakt Micro-Location Sp z o.o.
				Stoczniowcow 3
				Krakow    30-709
				PL

A0-02-4A   (hex)		Xi'an Yingsheng Electric Technology Co.,Ltd.
B00000-BFFFFF     (base 16)		Xi'an Yingsheng Electric Technology Co.,Ltd.
				Room 303, building B, Xi'an University of Technology science and Technology Park, 26 Gazelle road, Zhang Ba Street office,
				Xi'an    710065
				CN

78-D4-F1   (hex)		Quidel Corporation
D00000-DFFFFF     (base 16)		Quidel Corporation
				9975 Summers Ridge Road
				San Diego  CA  92121
				US

78-D4-F1   (hex)		Xiamen Cheerzing IOT Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Xiamen Cheerzing IOT Technology Co.,Ltd.
				Xiamen Cheerzing IOT Technology Co.,Ltd.
				Xiamen  FuJian  361002
				CN

34-E1-D1   (hex)		Biamp
900000-9FFFFF     (base 16)		Biamp
				9300 SW Gemini Drive
				Beaverton  OR  97008
				US

44-6F-D8   (hex)		ZHEJIANG HIKAILINK TECHNOLOGY Co., Ltd
A00000-AFFFFF     (base 16)		ZHEJIANG HIKAILINK TECHNOLOGY Co., Ltd
				Room 116, 1 / F, building 2, No. 87, Hexi, Changfeng street, Wuzhen Town, Tongxiang City
				Jiaxing City  Zhejiang  China
				CN

44-6F-D8   (hex)		Shenzhen Mestechs Technology CO., LTD
300000-3FFFFF     (base 16)		Shenzhen Mestechs Technology CO., LTD
				The 3rd Floor, E4A Bldg?TCL International E city, NO.1001 zhongshanyuan Rd, Nanshan District
				shenzhen  GuangDong  518052
				CN

98-27-82   (hex)		Guangzhou Wuzhou Technology Co, Ltd.
500000-5FFFFF     (base 16)		Guangzhou Wuzhou Technology Co, Ltd.
				4th Floor, Building C2, Hi-Tech Enterprise Accelerator, Kaiyuan Avenue #11, Huangpu District
				Guangzhou  Guangdong  510530
				CN

98-27-82   (hex)		Wuxi GuoYiHaiJu Technology Co.,Ltd.
900000-9FFFFF     (base 16)		Wuxi GuoYiHaiJu Technology Co.,Ltd.
				Innovation Industrial Park E2-2F
				hefei    230000
				CN

98-27-82   (hex)		Nanjing BianYu Future Home Technology Co.Ltd
A00000-AFFFFF     (base 16)		Nanjing BianYu Future Home Technology Co.Ltd
				 Longyu Middle Street
				Beijing  Beijing  100085
				CN

98-27-82   (hex)		CATS Power design
800000-8FFFFF     (base 16)		CATS Power design
				144 route des Vernes
				PRINGY    74370
				FR

04-11-19   (hex)		Alethea Communications Technologies Pvt. Ltd.
200000-2FFFFF     (base 16)		Alethea Communications Technologies Pvt. Ltd.
				2346, 17th Cross, HSR Layout
				Bangalore  Karnataka  560102
				IN

E8-6C-C7   (hex)		Huaqin Technology Co.,Ltd
700000-7FFFFF     (base 16)		Huaqin Technology Co.,Ltd
				No. 10 Keyuan Road, Songshan Lake
				Dongguan  Guangdong  523808
				CN

04-11-19   (hex)		Acentury
100000-1FFFFF     (base 16)		Acentury
				120 West Beaver Creek Road, Unit 13
				Richmond Hill  ON  L4B 1L2
				CA

E8-6C-C7   (hex)		CoxSpace
A00000-AFFFFF     (base 16)		CoxSpace
				858ho, Business Support Hub, 815, Daewangpangyo-ro Sujeong-gu
				Seongnam  Kyeonggi-do  13449
				KR

38-B8-EB   (hex)		Sirin Mobile Technologies
700000-7FFFFF     (base 16)		Sirin Mobile Technologies
				Muhlentalstrasse 2
				Schaffhausen    8200
				CH

24-5D-FC   (hex)		TORGOVYY DOM  TEHNOLOGIY LLC
900000-9FFFFF     (base 16)		TORGOVYY DOM  TEHNOLOGIY LLC
				Gospytalnaya 10, ap. 109, village Selyatino, city Naro-Fominsk,
				Moscow  Moscow Region  143345
				RU

24-5D-FC   (hex)		ContactProximity Inc
500000-5FFFFF     (base 16)		ContactProximity Inc
				241 Arlington Street #966
				Acton  MA  01720
				US

24-5D-FC   (hex)		CompanyDeep
000000-0FFFFF     (base 16)		CompanyDeep
				122, Ross Street
				Cambridge  Cambridgeshire  CB13BU
				GB

24-5D-FC   (hex)		Guangzhou Lango Electronics Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Guangzhou Lango Electronics Technology Co.,Ltd.
				Room 238, Room 406, No. 1, Yichuang Street, Huangpu District
				Guangzhou  Guangdong  510336
				CN

F0-23-B9   (hex)		Shenyang Ali Technology Company Limited
D00000-DFFFFF     (base 16)		Shenyang Ali Technology Company Limited
				No.17-5, Wensu Street
				Dongling District  Shenyang Liaoning Province  110168
				CN

0C-5C-B5   (hex)		Hunan Newman Car NetworKing Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Hunan Newman Car NetworKing Technology Co.,Ltd
				128 Lixiang East Road,ChangshaEconomic and Technological Development Zone
				Changsha  Hunan  410100
				CN

0C-5C-B5   (hex)		S2C limited
600000-6FFFFF     (base 16)		S2C limited
				E1 No.2555 Xiupu Rd. Pudong New Area
				Shanghai	  Shanghai	  201135
				CN

1C-A0-EF   (hex)		Tangshan Liulin Automation Equipment Co., Ltd.
000000-0FFFFF     (base 16)		Tangshan Liulin Automation Equipment Co., Ltd.
				Building 110-3, No.410 Huoju Road, High-tech Zone
				Tangshan City  Hebei Province  063000
				CN

1C-A0-EF   (hex)		LLC Gagar.In
C00000-CFFFFF     (base 16)		LLC Gagar.In
				Rybnikov Pereulok 1
				Moscow    107045
				RU

1C-A0-EF   (hex)		Zillnk
800000-8FFFFF     (base 16)		Zillnk
				No. 505, 5 / F, Unit 2, building 1, No. 777, North Section of Yizhou Avenue, Chengdu High Tech Zone, China (Sichuan) Pilot Free Trade Zone
				Chengdu    610000
				CN

1C-A0-EF   (hex)		Leviathan Solutions Ltd.
400000-4FFFFF     (base 16)		Leviathan Solutions Ltd.
				Abel Jeno utca 23
				Budapest    1113
				HU

20-CE-2A   (hex)		Shanghai Digicube Info&Tech Co.,Ltd.
100000-1FFFFF     (base 16)		Shanghai Digicube Info&Tech Co.,Ltd.
				Room B, 9th floor, building 1, Hongqiao headquarters, 100 Zixiu Road, 
				Shanghai  Minhang District  201103
				CN

20-CE-2A   (hex)		Intelligraphics
800000-8FFFFF     (base 16)		Intelligraphics
				11615 Angus Road, Suite #104L
				Austin  TX  78759
				US

2C-D1-41   (hex)		Square Inc.
D00000-DFFFFF     (base 16)		Square Inc.
				1455 Market St.
				San Francisco  CA  94103
				US

88-C9-B3   (hex)		shenzhen franklin ESS technology CO.,Ltd
200000-2FFFFF     (base 16)		shenzhen franklin ESS technology CO.,Ltd
				102, 61 Liuxian Rd 2, Baoan Dst., Shenzhen
				shenzhen    518000
				CN

88-C9-B3   (hex)		Cervoz Technology Co; Ltd.
100000-1FFFFF     (base 16)		Cervoz Technology Co; Ltd.
				8F; No.10, Aly6, Ln.235, Baociao Rd; 
				Sindian Dist.  New Taipei City  23145
				TW

C8-F5-D6   (hex)		Oscars Pro
700000-7FFFFF     (base 16)		Oscars Pro
				A 45, 1st Floor, Sector 4
				Noida  Uttar Pradesh  201301
				IN

C8-F5-D6   (hex)		Pinmicro K K
500000-5FFFFF     (base 16)		Pinmicro K K
				Kanda Jimbocho, 2-20-13
				Chiyoda Ku  Tokyo  1010051
				JP

D0-9F-D9   (hex)		Shenzhen eloT Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Shenzhen eloT Technology Co.,Ltd
				North Wing of 2/F, Block 2, Viseen Technology & Business Park, No.43 Gaoxin South Ring Road
				Shenzhen  Guangdong  518000
				CN

C0-FB-F9   (hex)		Tiandi(Changzhou) Automation Co., Ltd.
A00000-AFFFFF     (base 16)		Tiandi(Changzhou) Automation Co., Ltd.
				Tiandi(Changzhou) Automation Co., Ltd.
				Changzhou  Jiangsu  213015
				CN

C0-FB-F9   (hex)		Navitas Digital Safety Ltd
E00000-EFFFFF     (base 16)		Navitas Digital Safety Ltd
				1ST FLOOR, 13  PHOENIX PARK 
				COALVILLE  Leicestershire  LE673HB
				GB

D0-9F-D9   (hex)		Poten (Shanghai) Technology Co.,Ltd.
400000-4FFFFF     (base 16)		Poten (Shanghai) Technology Co.,Ltd.
				Rm.B,6th Fl., No.5, Caoxi Rd.251
				Shanghai  Shanghai  200235
				CN

D0-9F-D9   (hex)		Raymax Technology Ltd.
700000-7FFFFF     (base 16)		Raymax Technology Ltd.
				604, Building D, No.1001 Wen Yi Xi Road
				Hangzhou  China  310012
				CN

D0-9F-D9   (hex)		Queclink Wireless Solutions Co., Ltd.
800000-8FFFFF     (base 16)		Queclink Wireless Solutions Co., Ltd.
				No.30, Lane 500, Xinlong Road, Minhang District
				Shanghai    201101
				CN

D0-9F-D9   (hex)		Fujian Newland Auto-ID Tech. Co,.Ltd.
C00000-CFFFFF     (base 16)		Fujian Newland Auto-ID Tech. Co,.Ltd.
				Newland Science & Technology Park, No.1 Rujiang West Rd,Mawei,Fuzhou, P.R.China
				Fuzhou    350015
				CN

D0-9F-D9   (hex)		Lemei Intelligent IOT (Shenzhen) Co., Ltd
000000-0FFFFF     (base 16)		Lemei Intelligent IOT (Shenzhen) Co., Ltd
				#1101, Building #1, Yishang Sanwei Inductry Park, Zhongwu, Hangcheng Street, Baoan District
				Shenzhen  Guangdong  518000
				CN

18-74-E2   (hex)		Kano Computing Limited
800000-8FFFFF     (base 16)		Kano Computing Limited
				Unit 12.1 - 12.2, 11-29 Fashion Street
				London    E1 6PX
				GB

A8-5B-36   (hex)		Luoxian (Guandong) Technology Co., Ltd
400000-4FFFFF     (base 16)		Luoxian (Guandong) Technology Co., Ltd
				4th floor,building 4,European Industrial Park,60 Longbao West Road,Zhangcha Town
				FoShan  Guandong  528051
				CN

A8-5B-36   (hex)		TAIDEN INDUSTRIAL CO.,LTD
A00000-AFFFFF     (base 16)		TAIDEN INDUSTRIAL CO.,LTD
				6/F, Block B, Future Plaza, 6060 Qiaoxiang Rd, Nanshan District
				Shenzhen  Guangdong   518053
				CN

F0-2A-2B   (hex)		ZiGong Pengcheng Technology Co.,Ltd
900000-9FFFFF     (base 16)		ZiGong Pengcheng Technology Co.,Ltd
				80?Longxiang Road?Yantan District
				ZiGong  SiChuan   643221
				CN

A8-5B-36   (hex)		Avista Edge
900000-9FFFFF     (base 16)		Avista Edge
				12 N Sheridan St
				Spokane  WA  99202
				US

F0-2A-2B   (hex)		Protronix s.r.o.
700000-7FFFFF     (base 16)		Protronix s.r.o.
				Pardubická 177
				Chrudim    537 01
				CZ

F0-2A-2B   (hex)		Tobi Tribe Inc.
100000-1FFFFF     (base 16)		Tobi Tribe Inc.
				45945 Trefoil Ln #157
				 Sterling  VA  20166
				US

58-48-49   (hex)		Shenzhen hongqifu Technology Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen hongqifu Technology Co., Ltd
				1003-1004, building B, Shenye century industrial center, NO743,  Zhoushi Road, Hezhou community, Hangcheng street, Bao'an District
				Shenzhen    518126
				CN

58-48-49   (hex)		Daatrics LTD
B00000-BFFFFF     (base 16)		Daatrics LTD
				4th Floor, 86-90 Paul Street
				LONDON    EC2A 4NE
				GB

58-48-49   (hex)		Shandong Aotai Electric Co., LTD.
700000-7FFFFF     (base 16)		Shandong Aotai Electric Co., LTD.
				282 Bole Avenue, High-tech Development Zone Shandong P.R. China
				Jinan  Shandong  250101
				CN

64-33-B5   (hex)		Duomondi International Development Co., Ltd.
000000-0FFFFF     (base 16)		Duomondi International Development Co., Ltd.
				Unit D 19/F Roxy Industry Center 59-66 Tai Lin Pai
				Kwai Chung  NT  999077
				HK

64-33-B5   (hex)		University of Texas at Austin
E00000-EFFFFF     (base 16)		University of Texas at Austin
				1 University Station C3800
				Austin  TX  78713-7407
				US

28-36-13   (hex)		Elytone Electronic Co., Ltd.
400000-4FFFFF     (base 16)		Elytone Electronic Co., Ltd.
				#218, Sec.2, Chung Cheng Road
				San-Hsia District, New Taipei City    23742
				TW

28-36-13   (hex)		Qingdao Airpoint Electronics Co.,Ltd.
900000-9FFFFF     (base 16)		Qingdao Airpoint Electronics Co.,Ltd.
				Yuhuangling industrial Park, Xiazhuang-Rd, Chengyang-Qu
				QingDao City  ShanDong Province  266109
				CN

78-5E-E8   (hex)		TOPDON TECHNOLOGY Co.,Ltd.
900000-9FFFFF     (base 16)		TOPDON TECHNOLOGY Co.,Ltd.
				Nanshan
				Shenzhen  Guangdong  518000
				CN

78-5E-E8   (hex)		RIKEN KEIKI NARA MFG. Co., Ltd.
100000-1FFFFF     (base 16)		RIKEN KEIKI NARA MFG. Co., Ltd.
				49-1 Abe
				Sakurai city    633-0054
				JP

38-A8-CD   (hex)		Shenzhen C & D Electronics Co., Ltd.
700000-7FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

38-A8-CD   (hex)		Qingdao Hisense Hitachi Air-conditioning Systems Co.,Ltd.
B00000-BFFFFF     (base 16)		Qingdao Hisense Hitachi Air-conditioning Systems Co.,Ltd.
				No.218, Qianwangang Road, Qingdao Economic Development Zone, China
				Qingdao    266510
				CN

38-A8-CD   (hex)		Beijing Porient Technology Co., Ltd
200000-2FFFFF     (base 16)		Beijing Porient Technology Co., Ltd
				Room 901,Power Creative A,No.1, Shangdi East Road,Haidian ,
				BEIJING    100085
				CN

38-A8-CD   (hex)		Beijing Aumiwalker technology CO.,LTD
C00000-CFFFFF     (base 16)		Beijing Aumiwalker technology CO.,LTD
				Floor 6, Tower 1, No.1 Zhonghe Road Fengtai Science Park Beijing P.R.C.
				Beijing  Beijing  100071
				CN

38-A8-CD   (hex)		Max Way Electronics Co., Ltd.
800000-8FFFFF     (base 16)		Max Way Electronics Co., Ltd.
				8F-12, No.121, Sec. 1, Chongqing S. Rd., Zhongzheng Dist.,
				Taipei City    100
				TW

38-A8-CD   (hex)		ACiiST Smart Networks Ltd.
000000-0FFFFF     (base 16)		ACiiST Smart Networks Ltd.
				119 Ha'Mamshichim
				Kfar Varburg    7099800
				IL

38-A8-CD   (hex)		cal4care Pte Ltd
600000-6FFFFF     (base 16)		cal4care Pte Ltd
				118 Aljunied AVE 2
				SINGAPORE  SINGAPORE  380118
				SG

7C-83-34   (hex)		PEMtronics LLC
200000-2FFFFF     (base 16)		PEMtronics LLC
				70 SW Century Dr Ste 100 Box 427
				Bend    97702
				US

7C-83-34   (hex)		Wojinxin Beijing Technology Co., LTD
600000-6FFFFF     (base 16)		Wojinxin Beijing Technology Co., LTD
				315-1, 3rd floor, No. 15, information road, Haidian District
				Beijing    100089
				CN

7C-83-34   (hex)		Linear Logic LLC
100000-1FFFFF     (base 16)		Linear Logic LLC
				2222 S. Dobson Rd. Suite 800
				Mesa  AZ  85202
				US

7C-83-34   (hex)		Fusus
400000-4FFFFF     (base 16)		Fusus
				5550 TRIANGLE PKWY, STE 385
				PEACHTREE CORNERS  GA  30092
				US

1C-AE-3E   (hex)		QuEST Rail LLC
C00000-CFFFFF     (base 16)		QuEST Rail LLC
				106 E Highway 224
				Wellington  MO  64097
				US

7C-83-34   (hex)		Balter GmbH
E00000-EFFFFF     (base 16)		Balter GmbH
				Elisabeth-Selbert-Strasse 19
				Langenfeld    40764
				DE

1C-AE-3E   (hex)		HagerEnergy GmbH
300000-3FFFFF     (base 16)		HagerEnergy GmbH
				Karlstrasse 5
				Osnabrueck    49074
				DE

98-6E-E8   (hex)		Sisgeo Srl
800000-8FFFFF     (base 16)		Sisgeo Srl
				Via F. Serpero 4/F1
				Masate  Milano  20060
				IT

98-80-BB   (hex)		Hilo
B00000-BFFFFF     (base 16)		Hilo
				4-6 Kiprou str
				Tavros  Athens  17778
				GR

98-80-BB   (hex)		Guangdong-Hong Kong-Macao Greater Bay Area Research Innovation Institute for Nanotechnology 
700000-7FFFFF     (base 16)		Guangdong-Hong Kong-Macao Greater Bay Area Research Innovation Institute for Nanotechnology 
				Building D, 136 Kaiyuan Avenue, Guangzhou High- tech Industrial Development Zone 
				GuangZhou  Guangdong  510700
				CN

78-72-64   (hex)		Guangdong Hongqin Telecom Technology Co.,Ltd.
300000-3FFFFF     (base 16)		Guangdong Hongqin Telecom Technology Co.,Ltd.
				10 Keyuan Road, Songshan Lake
				Dongguan   Guangdong   523429
				CN

98-80-BB   (hex)		Shenzhen Hebang Electronic Co., Ltd
900000-9FFFFF     (base 16)		Shenzhen Hebang Electronic Co., Ltd
				2nd Floor West, Bldg B, Kelunte Low Carbon Industry Park, Huarong Road, Dalang, Longhua District
				Shenzhen    518000
				CN

78-72-64   (hex)		SmartMore Co.,ltd.
000000-0FFFFF     (base 16)		SmartMore Co.,ltd.
				22nd Floor,Sanhang Technology Building,Nanshan ShenZhen,China
				 ShenZhen  GuangDong  518000
				CN

F4-70-0C   (hex)		G.S.D GROUP INC.
C00000-CFFFFF     (base 16)		G.S.D GROUP INC.
				2010 RUE MICHELIN, SUITE 100
				LAVAL  Quebec  H7L 5C2
				CA

F4-70-0C   (hex)		Shenzhen Focuscom Communication Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Shenzhen Focuscom Communication Technology Co.,Ltd.
				209, Integrated Circuit Industrial Park, Chaguang Road, Nanshan District
				Shenzhen  Guangdong  518000
				CN

F4-70-0C   (hex)		Union Source Technology(HK)LTD
300000-3FFFFF     (base 16)		Union Source Technology(HK)LTD
				FLAT/RM 1405B 14/F THE BELGIAN BANK BUILDING NOS.721-725 NATHAN ROAD MONGKOK
				Hong Kong    999077
				HK

78-72-64   (hex)		BZBGEAR
200000-2FFFFF     (base 16)		BZBGEAR
				830 National dr ste 140
				Sacramento  CA  95834
				US

F4-70-0C   (hex)		Jinan Huake Electrical Device Co., Ltd.
A00000-AFFFFF     (base 16)		Jinan Huake Electrical Device Co., Ltd.
				Room 415-7, Hongxing Building, No.1 Hongxing Road, Licheng District, 
				Jinan  Shandong  250000
				CN

C8-63-14   (hex)		Freeus LLC
C00000-CFFFFF     (base 16)		Freeus LLC
				1069 Stewart Drive, Suites 3-6
				Ogden  UT  84404
				US

F4-A4-54   (hex)		Graco Inc.
B00000-BFFFFF     (base 16)		Graco Inc.
				PO Box 1441 
				Minneapolis    55440
				US

74-F8-DB   (hex)		ATX
300000-3FFFFF     (base 16)		ATX
				5850 Hellyer Ave
				San Jose  CA  95138
				US

F4-A4-54   (hex)		PT Telkom Indonesia
100000-1FFFFF     (base 16)		PT Telkom Indonesia
				Jl. Gegerkalong Hilir no. 47, Sukasari
				Bandung  West Java  40152
				ID

F4-A4-54   (hex)		Care Bloom, LLC
E00000-EFFFFF     (base 16)		Care Bloom, LLC
				3401 Enterprise Parkway, Suite 205
				Cleveland  OH  44122
				US

F4-A4-54   (hex)		SAEL SRL
D00000-DFFFFF     (base 16)		SAEL SRL
				Via Tavani, 2/F
				Delebio  Sondrio  23014
				IT

18-45-B3   (hex)		Hangzhou CCRFID Microelectronic Co., Ltd.
B00000-BFFFFF     (base 16)		Hangzhou CCRFID Microelectronic Co., Ltd.
				East Zone,building four,Hangzhou Hi-tech Software park, NO.1 Weiye Road, Bin jiang District
				Hangzhou  Zhejiang  330046
				CN

18-45-B3   (hex)		Taicang T&W Electronics
D00000-DFFFFF     (base 16)		Taicang T&W Electronics
				89# Jiang Nan RD
				Suzhou  Jiangsu  215412
				CN

18-45-B3   (hex)		Ancsonic (chongqing) Electronic Science& Technology Co.,Ltd
300000-3FFFFF     (base 16)		Ancsonic (chongqing) Electronic Science& Technology Co.,Ltd
				No.644, No.117 yunhan Avenue, Beibei District, Chongqing, China
				chongqing    4000000
				CN

18-45-B3   (hex)		Teko Telecom Srl
900000-9FFFFF     (base 16)		Teko Telecom Srl
				via Meucci 24/a
				Castel San Pietro Terme  Bologna  40024
				IT

94-C9-B7   (hex)		Zhejiang Hengjie Communication Technology Co,. Ltd.
400000-4FFFFF     (base 16)		Zhejiang Hengjie Communication Technology Co,. Ltd.
				East 3F 23Building, Wenzhou National University Science Park, NO. 89 FengFang road, Ouhai econmic development Zone,
				Wenzhou  Zhejiang  325000
				CN

08-F8-0D   (hex)		SEDA CHEMICAL PRODUCTS CO., LTD.
600000-6FFFFF     (base 16)		SEDA CHEMICAL PRODUCTS CO., LTD.
				No 56, Bade Rd., Yingge Dist.,
				New Taipei City    23942
				TW

08-F8-0D   (hex)		Benelink Technology Inc.
900000-9FFFFF     (base 16)		Benelink Technology Inc.
				6F, No.95, Xinhu 1st Rd., Neihu Dist.
				Taipei    114
				TW

50-A0-30   (hex)		GUANGZHOU UNIPOWER COMPUTER CO.,LTD
C00000-CFFFFF     (base 16)		GUANGZHOU UNIPOWER COMPUTER CO.,LTD
				Room 3203, No. 233 Tianhe North Road, Tianhe District,
				Guangzhou    510000
				CN

50-A0-30   (hex)		GE Medical System China Co. Ltd.
800000-8FFFFF     (base 16)		GE Medical System China Co. Ltd.
				No. 19 ChangJiang Road National Hi-Tech DEV. Zone
				Wuxi  Jiangsu  214028
				CN

50-A0-30   (hex)		Gopod Group Limited
000000-0FFFFF     (base 16)		Gopod Group Limited
				5-6/f,building 8,Lianjian Industrial Park,Longhua
				Shenzhen    518109
				CN

50-A0-30   (hex)		RealWear (Shanghai) Intelligent Technology Co. Ltd
300000-3FFFFF     (base 16)		RealWear (Shanghai) Intelligent Technology Co. Ltd
				2F,Block21, No.55 Chuanhe Road, Pudong New District
				Shanghai  Shanghai  201210
				CN

04-EE-E8   (hex)		Privacy Hero
900000-9FFFFF     (base 16)		Privacy Hero
				3-1136 Centre Street, suite 152
				Thornhill  Ontario  L4J 3M8
				CA

04-EE-E8   (hex)		Hunan Yaguan Communication Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Hunan Yaguan Communication Technology Co.,Ltd
				13th Floor, China Power Software Park, High-tech Development Zone, Changsha City
				Changsha    410000
				CN

04-EE-E8   (hex)		NALSSEN INC.
600000-6FFFFF     (base 16)		NALSSEN INC.
				17, Yeokgok-ro 13beon-gil, Bucheon-si, Gyeonggi-do, Republic of Korea
				Gyeonggi-do  Gyeonggi-do  14671
				KR

04-EE-E8   (hex)		Best Integration Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Best Integration Technology Co., Ltd.
				5F., No.1, Ln.63, Guanxin Rd., East Dist
				Hsinchu City  Taiwan  30072
				TW

04-EE-E8   (hex)		Zoomlion Huanuo(Beijing)Technology Co.,Ltd
000000-0FFFFF     (base 16)		Zoomlion Huanuo(Beijing)Technology Co.,Ltd
				Room 401, floor 4, unit 2, building 26, yard 1, Disheng North Street, Beijing Economic and Technological Development Zone, Beijing
				Beijing    100000
				CN

18-D7-93   (hex)		Shenzhen JieXingTong Technology Co.,LTD
000000-0FFFFF     (base 16)		Shenzhen JieXingTong Technology Co.,LTD
				3rd floor,block C,B6 building,China Merchants guangming science and technology park,No.3009 guanguang road,Guangming New District,
				Shenzhen    518000
				CN

18-D7-93   (hex)		Verification & Validation Technology Co.,Ltd
300000-3FFFFF     (base 16)		Verification & Validation Technology Co.,Ltd
				Room 1802, Building 3, Xunmei Technology Plaza, No.8 Keyuan Road, Science Park Community, Yuehai Street, Nanshan District  
				shenzhen  guangdong  518057
				CN

18-D7-93   (hex)		Torsa Global
800000-8FFFFF     (base 16)		Torsa Global
				C/ Severo Ochoa, 19
				Malaga  Malaga  29590
				ES

DC-36-43   (hex)		Wuhan Linptech Co. ,Ltd.
200000-2FFFFF     (base 16)		Wuhan Linptech Co. ,Ltd.
				3F,Bldg 1A,Lianxiang Enterprise Center
				Wuhan  Hubei  430074
				CN

08-26-AE   (hex)		F-Plus Mobile LLC
B00000-BFFFFF     (base 16)		F-Plus Mobile LLC
				Preobrazhenskaya square, 8, floor 27, pom. LXXXVI, room 1.
				Moscow  Moscow  107061
				RU

08-26-AE   (hex)		Beijing Silion Technology Corp.,Ltd.
100000-1FFFFF     (base 16)		Beijing Silion Technology Corp.,Ltd.
				#508, Building A, No.3 Longyu North St.
				Changping  Beijing  102200
				CN

DC-36-43   (hex)		Shenzhen smart-core technology co.,ltd.
600000-6FFFFF     (base 16)		Shenzhen smart-core technology co.,ltd.
				19/F., Finance & Technology Building, No.11 Keyuan Road, Nanshan Dist., Shenzhen, China
				Shenzhen  Guangdong  518057
				CN

08-26-AE   (hex)		ShineTech Electronics Co., Ltd
800000-8FFFFF     (base 16)		ShineTech Electronics Co., Ltd
				No.169, Anji St., Zuoying Dist.
				Kaohsiung    813018
				TW

08-26-AE   (hex)		SHENNAN CIRCUITS CO.,LTD
500000-5FFFFF     (base 16)		SHENNAN CIRCUITS CO.,LTD
				Gao Qiao Industrial Park East,Long Gang District,
				Shenzhen  Guangdong  518117
				CN

DC-36-43   (hex)		UKG
700000-7FFFFF     (base 16)		UKG
				900 Chelmsford St
				Lowell  MA  01851
				US

DC-36-43   (hex)		Beijing L&S Lancom Platform Tech. Co., Ltd.
E00000-EFFFFF     (base 16)		Beijing L&S Lancom Platform Tech. Co., Ltd.
				901,floor 9, jelly loft, building 28, yard 9, Huinan Road, Changping District.
				Beijing    102208
				CN

08-26-AE   (hex)		Annapurna labs
900000-9FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

98-8F-E0   (hex)		Shenzhen Vitalitim Technology Co., Ltd
D00000-DFFFFF     (base 16)		Shenzhen Vitalitim Technology Co., Ltd
				83C21J, 3rd Floor, Tianjing Building, Tian'an Digital City, No. 6, Tairan 5th Road, Tian'an Community, Shatou Street, Futian District,
				Shenzhen  Guangdong  518000
				CN

98-8F-E0   (hex)		GUANGZHOU HERYSTORM TECHNOLOGY CO.,LTD.
100000-1FFFFF     (base 16)		GUANGZHOU HERYSTORM TECHNOLOGY CO.,LTD.
				No.2-8,Nancun North Street,Panyun District,
				Guangzhou    511400
				CN

10-54-D2   (hex)		Bamboo Dynamics Corporation., Ltd.
900000-9FFFFF     (base 16)		Bamboo Dynamics Corporation., Ltd.
				No.146, Sec. 1,Donxing Rd.
				Zhubei City, Hsinchu County   Taiwan  302058
				TW

10-54-D2   (hex)		Raylogic Control Systems Private Limited
400000-4FFFFF     (base 16)		Raylogic Control Systems Private Limited
				Unit 6, 3rd floor, HILIFE, PM Road, Santacruz West
				Mumbai  Maharashtra  400054
				IN

10-54-D2   (hex)		Sybersense
500000-5FFFFF     (base 16)		Sybersense
				Unit 10, 16F, Hi-Tech Industrial Centre, Block A, 5-21 Pat Tin Par Street, Tsuen Wan NT, HK
				Hong Kong    999077
				CN

10-54-D2   (hex)		SHENZHEN CARSAFE TECHNOLOGY DEVELOPMENT CO.,LTD
700000-7FFFFF     (base 16)		SHENZHEN CARSAFE TECHNOLOGY DEVELOPMENT CO.,LTD
				Bldg.7, N.Industrial Park,No.18 Makan Rd,Xili,Nanshan,
				SHENZHEN    518000
				CN

0C-86-29   (hex)		Shanghai Prophet Electronic Technology Co.,Ltd
000000-0FFFFF     (base 16)		Shanghai Prophet Electronic Technology Co.,Ltd
				9th Floor, Building 3, 1535 Hongmei Road, Xuhui District,
				Shanghai    200030
				CN

0C-86-29   (hex)		Beijing Qinmu Data Technology Co., Ltd.
100000-1FFFFF     (base 16)		Beijing Qinmu Data Technology Co., Ltd.
				Room101,Office 701,Floor7,Building4,Courtyard1,Nongda South Road,Haidian District.
				Beijing    100085
				CN

0C-86-29   (hex)		C&A Marketing, INC.
600000-6FFFFF     (base 16)		C&A Marketing, INC.
				114 Tived Lane East
				Edison   NJ  08837
				US

0C-86-29   (hex)		MyGregor Ltd
800000-8FFFFF     (base 16)		MyGregor Ltd
				11A, Carnegie str.
				Sofia    1000
				BG

6C-93-08   (hex)		Annapurna labs
D00000-DFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

6C-93-08   (hex)		Shenzhen DOOGEE Hengtong Technology CO., LTD
900000-9FFFFF     (base 16)		Shenzhen DOOGEE Hengtong Technology CO., LTD
				B, 2/F, Building A4, Silicon Valley Power Digital Industrial Park, No. 22, Dafu Industrial Zone, Guanlan Aobei Community, Guanlan Street, Longhua New District
				Shenzhen  Guangdong  518000
				CN

6C-93-08   (hex)		Shenzhen TOPWAY Technology Co.,LTD
A00000-AFFFFF     (base 16)		Shenzhen TOPWAY Technology Co.,LTD
				Bld.20 Zone 5, Baiwangxin Industry Park, Songbai Rd.Nanshan Dist
				ShenZhen  Guangdong  518055
				CN

30-43-D7   (hex)		SYMES SA
000000-0FFFFF     (base 16)		SYMES SA
				4 allée technopolis, chemin des presses
				Cagnes sur mer  PACA  06800
				FR

30-43-D7   (hex)		Shenzhen Mees Hi-Tech Co., Ltd
500000-5FFFFF     (base 16)		Shenzhen Mees Hi-Tech Co., Ltd
				2F & 4F,Building 3 North District,2nd Qianjin Road,Liutang Village, Xixiang,Bao'an District
				Shenzhen  Guangdong  518102
				CN

30-43-D7   (hex)		Annapurna labs
D00000-DFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

6C-93-08   (hex)		ANDDORO LLC
E00000-EFFFFF     (base 16)		ANDDORO LLC
				1430 Broadway NY 
				New York  NY  10018
				US

38-1F-26   (hex)		Synamedia
200000-2FFFFF     (base 16)		Synamedia
				Luipaardstraat 12
				Kortrijk  West-Vlaanderen  8500
				BE

38-1F-26   (hex)		Jade Bird Fire Co., Ltd.
C00000-CFFFFF     (base 16)		Jade Bird Fire Co., Ltd.
				Jade Bird Building, 207 Chengfu Road, Haidian District, Beijing, P.R.China
				Beijing    100871
				CN

38-1F-26   (hex)		Zhejiang Huazhou Intelligent Equipment Co,. Ltd
500000-5FFFFF     (base 16)		Zhejiang Huazhou Intelligent Equipment Co,. Ltd
				Building3, No.416DdongshengAvenue, Wuzhen, Tongxiang, 
				Jiaxing    314000
				CN

18-A5-9C   (hex)		Omwave
000000-0FFFFF     (base 16)		Omwave
				5 rue Barbes
				Montrouge    92120
				FR

18-A5-9C   (hex)		INTEGRAL PLUS
600000-6FFFFF     (base 16)		INTEGRAL PLUS
				ul. Khalitova, 2
				Kazan    420029
				RU

18-A5-9C   (hex)		estun automation co.,ltd
900000-9FFFFF     (base 16)		estun automation co.,ltd
				1888 Jiyin Avenue,Jiangning District
				nanjing    211100
				CN

1C-59-74   (hex)		Topway Global Technology Limited
800000-8FFFFF     (base 16)		Topway Global Technology Limited
				Room 1003, 10 / F, Tower 1, Lippo Centre, 89 Queensway, Hong Kong  
				Hong Kong  Hong Kong  999077
				HK

1C-59-74   (hex)		King-On Technology Ltd.
C00000-CFFFFF     (base 16)		King-On Technology Ltd.
				13F, No.207-2, Sec#3, Beixin Rd., Xindian District.
				New Taipei  Taiwan  23146
				TW

1C-59-74   (hex)		Shenzhen Geshem Technology Co Ltd
D00000-DFFFFF     (base 16)		Shenzhen Geshem Technology Co Ltd
				12th Floor, Block B, Building 7, International Innovation Valley
				Shenzhen  Gunagdong  518000
				CN

18-A5-9C   (hex)		Annapurna labs
D00000-DFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

18-A5-9C   (hex)		BMC Messsysteme GmbH
E00000-EFFFFF     (base 16)		BMC Messsysteme GmbH
				Haupstr. 21
				Maisach    82216
				DE

1C-59-74   (hex)		Jiangsu Welm Technology Co.,Ltd
300000-3FFFFF     (base 16)		Jiangsu Welm Technology Co.,Ltd
				No.158 Jianghai WestRoad,Haian
				Haian  Jiangsu  226100
				CN

1C-59-74   (hex)		Logical Infrastructure PTY LTD
100000-1FFFFF     (base 16)		Logical Infrastructure PTY LTD
				unit 2, 8 Carbine way
				Mornington  Victoria  3931
				AU

1C-59-74   (hex)		Shenzhen Shi Fang Communication Technology Co., Ltd
500000-5FFFFF     (base 16)		Shenzhen Shi Fang Communication Technology Co., Ltd
				601-6 Mitehuapujing No.9 Jinxiu Mid Road Longtian Street Pingshan Distinct
				Shenzhen   Guangdong  518118
				CN

1C-59-74   (hex)		Lynxi Technologies Co.,Ltd.
700000-7FFFFF     (base 16)		Lynxi Technologies Co.,Ltd.
				RM 801, 8/F, No. 67 North 4th Ring West Road
				Beijing  Beijing  100084
				CN

6C-15-24   (hex)		D-HOME SMAART
900000-9FFFFF     (base 16)		D-HOME SMAART
				8, rue Edouard Herriot
				Marigny le Châtel    10350
				FR

6C-15-24   (hex)		Forcite Helmet Systems Pty Ltd
300000-3FFFFF     (base 16)		Forcite Helmet Systems Pty Ltd
				35-39 Bourke Road, Alexandria
				Sydney  NSW  2015
				AU

6C-15-24   (hex)		Kunshan Abram Software Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Kunshan Abram Software Technology Co.,Ltd.
				Room 704, No. 666, Changjiang South Road
				Kunshan  Jiangsu  215300
				CN

6C-15-24   (hex)		Magicyo Technology CO., LTD.
400000-4FFFFF     (base 16)		Magicyo Technology CO., LTD.
				7F, Tower A, YuZhou Building, No.78 North Keyuan
				Shenzhen  Nanshan District  518057
				CN

70-50-E7   (hex)		shenzhen newbridge communication equipment CO.,LTD
C00000-CFFFFF     (base 16)		shenzhen newbridge communication equipment CO.,LTD
				5 / F, No. 1 building, Jinli Industrial Park, No. 1, LanJin Sixth Road, Nanbu community, Longtian street, Pingshan District, Shenzhen
				SHENZHEN  GUANGDONG  518000
				CN

70-50-E7   (hex)		Quantumdoor Technologies, Inc.
400000-4FFFFF     (base 16)		Quantumdoor Technologies, Inc.
				1st Floor 108-1,Buiding5,East Districe,No.10 Xibeiwang East Road,haidian Districe,
				beijing    102629
				CN

80-02-F4   (hex)		Shenzhen Suanzi Technology Co., Ltd
300000-3FFFFF     (base 16)		Shenzhen Suanzi Technology Co., Ltd
				Room 207, Research Building, Tsinghua Information Port, No.1, Songpingshan New East Road, Nanshan District
				Shenzhen  Guangdong  518057
				CN

8C-51-09   (hex)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
A00000-AFFFFF     (base 16)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
				NO.8 Tangzhuang Road,Suzhou Industrial Park,Su ZhouCity,JiangSu Province,China
				Suzhou    215021
				CN

8C-51-09   (hex)		TianJin JointOptic Technology Co., LTD.
000000-0FFFFF     (base 16)		TianJin JointOptic Technology Co., LTD.
				Floor 3, Building 6, Teda Service Outsourcing Industrial Park, 19 Xinhuan West Road, Binhai New Area, 
				Tianjin    300000
				CN

8C-51-09   (hex)		Shenzhen WOWOTO Technology Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen WOWOTO Technology Co., Ltd.
				Room B508,Building B,Gaoxingqi Industrial Park,Liuxian 1st Road,District 67,Bao'an
				Shenzhen  Guangdong  518100
				CN

8C-51-09   (hex)		Beijing Superhexa Century Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Beijing Superhexa Century Technology Co., Ltd.
				Room 1022, 1F, Zone A, No.1, South Back Street, Anningzhuang, Haidian District, Beijing
				Beijing    100010
				CN

E4-95-6E   (hex)		Tband srl
100000-1FFFFF     (base 16)		Tband srl
				Via Camucina 27/A
				PORTOGRUARO  Venezia  30026
				IT

0C-7F-ED   (hex)		ALT Co., Ltd.
D00000-DFFFFF     (base 16)		ALT Co., Ltd.
				#1201, 8, Seongnam-dearo 331beon-gil
				Bundang-gu, Seongnam-si  Gyeonggi-do  13558
				KR

0C-7F-ED   (hex)		Shenzhen ORVIBO Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen ORVIBO Technology Co., Ltd.
				F7, Block A7, Nanshan I Park, No.1001 XueYuan Avenue , NanShan District, ShenZhen 518055 PRC.
				shenzhen    518000
				CN

0C-7F-ED   (hex)		Netweb Technologies India Pvt Ltd
600000-6FFFFF     (base 16)		Netweb Technologies India Pvt Ltd
				Plot H1, Pocket-9, FIT,Sector-57, Ballabhgarh
				Faridabad  Haryana  121004
				IN

FC-61-79   (hex)		Kvaliteta Systems and Solutions Private Limited 
700000-7FFFFF     (base 16)		Kvaliteta Systems and Solutions Private Limited 
				2207 Yamuna Building Techno Park Phase 3
				Trivandrum  Kerala   695583
				IN

20-85-93   (hex)		UNILUMIN GROUP CO.,LTD
300000-3FFFFF     (base 16)		UNILUMIN GROUP CO.,LTD
				No.112 Yongfu Rd.,BaoanDistrict,
				shenzhen  guangdong  518103
				CN

20-85-93   (hex)		Eilersen Electric A/S
600000-6FFFFF     (base 16)		Eilersen Electric A/S
				Kokkedal Industripark 4
				Kokkedal    2980
				DK

4C-4B-F9   (hex)		Stored Energy Systems
B00000-BFFFFF     (base 16)		Stored Energy Systems
				1840 Industrial Circle
				Longmont  CO  80501
				US

24-15-10   (hex)		SHANDONG KEHUI POWER AUTOMATION CO. LTD.
600000-6FFFFF     (base 16)		SHANDONG KEHUI POWER AUTOMATION CO. LTD.
				 No. 16,Sanying Road
				Zibo  Shandong  255087
				CN

24-15-10   (hex)		Kaiyun
300000-3FFFFF     (base 16)		Kaiyun
				Fuhao
				Dongguang    523617
				CN

DC-44-27   (hex)		Private
F00000-FFFFFF     (base 16)		Private

2C-D1-41   (hex)		IntelliLUM
200000-2FFFFF     (base 16)		IntelliLUM
				8850 Terabyte Court
				Reno  Nevada  89521
				US

98-06-37   (hex)		Shenzhen Y&D Electronics Information Co., Ltd
800000-8FFFFF     (base 16)		Shenzhen Y&D Electronics Information Co., Ltd
				601-602, 6/F, Antenna Building, No 17, Keji North 1st Road, Nanshan District
				Shenzhen    518055
				CN

98-06-37   (hex)		BOEING SSG
600000-6FFFFF     (base 16)		BOEING SSG
				5905 LEGACY DR, SUITE 325
				PLANO  TX  75024
				US

1C-21-D1   (hex)		Private
F00000-FFFFFF     (base 16)		Private

FC-A4-7A   (hex)		SHENZHEN KUKU TECHNOLOGY CO.,LTD
D00000-DFFFFF     (base 16)		SHENZHEN KUKU TECHNOLOGY CO.,LTD
				No.205,2F,17th Block,PingShan Industrial District,TaoYuan Street, NanShan
				ShenZhen  GuangDong  518055
				CN

D0-5F-64   (hex)		Shenzhen Canzone Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Shenzhen Canzone Technology Co.,Ltd.
				Minzhi Street Longhua District
				ShenZhen    518000
				CN

2C-16-BD   (hex)		Curtiss-Wright Drive Technology
100000-1FFFFF     (base 16)		Curtiss-Wright Drive Technology
				Badstrasse 5
				Neuhausen am Rheinfall  Schaffhausen  8212
				CH

2C-16-BD   (hex)		Saft AB
300000-3FFFFF     (base 16)		Saft AB
				Jungnergatan
				Oskarshamn    57228
				SE

2C-16-BD   (hex)		Beijing Jishi Huitong Technology Co., Ltd.
000000-0FFFFF     (base 16)		Beijing Jishi Huitong Technology Co., Ltd.
				4/F,No.3 building,No.8,Haiying Road,Fengtai District
				Beijing  Beijing  100070
				CN

2C-16-BD   (hex)		AIMCO
200000-2FFFFF     (base 16)		AIMCO
				10000 SE Pine St
				Portland  OR  97216
				US

2C-16-BD   (hex)		SCT OPTRONICS CO., LTD
700000-7FFFFF     (base 16)		SCT OPTRONICS CO., LTD
				Floor 9, Block B, Building 7, Shenzhen Bay Technology Ecological Park, Nanshan District
				Shenzhen  Guangdong  518057
				CN

2C-16-BD   (hex)		Shanghai Walktech Information Technology Co.,Ltd.
900000-9FFFFF     (base 16)		Shanghai Walktech Information Technology Co.,Ltd.
				4F , No 85, Lane 1198, North Qin Zhou Road, Xu Hui District
				Shanghai  Shanghai  200233
				CN

FC-A4-7A   (hex)		Oberix Group Pty Ltd
900000-9FFFFF     (base 16)		Oberix Group Pty Ltd
				22 McIntyre Street
				Burwood  VIC  3125
				AU

FC-A4-7A   (hex)		KARRY COMMUNICATION LIMITED
800000-8FFFFF     (base 16)		KARRY COMMUNICATION LIMITED
				FLAT/RM 705 7/F SUNBEAM PLAZA 1155 CANTON ROAD MONGKOK KL
				Hong Kong    999077
				HK

8C-59-3C   (hex)		Nanonord A/S
800000-8FFFFF     (base 16)		Nanonord A/S
				Skjernvej 4A
				Aalborg    9220
				DK

8C-59-3C   (hex)		Future Robot Technology Co., Limited
100000-1FFFFF     (base 16)		Future Robot Technology Co., Limited
				Room 406 Block A South Wind Tower, Nanshan Cloud Valley Innovation Industry Park, No 4093 Lau Sin Avenue Taoyuan Street Nanshan District
				Shenzhen  Guangdong  518000
				CN

8C-59-3C   (hex)		Spectranetix
500000-5FFFFF     (base 16)		Spectranetix
				845 Stewart Drive, Suite B
				Sunnyvale  CA  94085
				US

B4-A2-EB   (hex)		SHENZHEN ZHUIFENGMA TECHNOLOGY CO., LTD
800000-8FFFFF     (base 16)		SHENZHEN ZHUIFENGMA TECHNOLOGY CO., LTD
				2 FLOOR WEST WING BLOCK 3  NO.28 LANGSHAN ROAD, NANSHAN DISTRICT 
				SHENZHEN  Guangdong  518040
				CN

B4-A2-EB   (hex)		SALZBRENNER media GmbH
D00000-DFFFFF     (base 16)		SALZBRENNER media GmbH
				Industriegebiet See 1
				Buttenheim    96155
				DE

BC-97-40   (hex)		Shenzhen Colorwin Optical Technology Co.,Ltd
600000-6FFFFF     (base 16)		Shenzhen Colorwin Optical Technology Co.,Ltd
				201-2，2nd Floor,G3 Building, TCL International E City,1001 Zhongshanyuan Road,Nanshan District
				Shenzhen  Guangdong  518055
				CN

BC-97-40   (hex)		Direct Communication Solutions
900000-9FFFFF     (base 16)		Direct Communication Solutions
				17150 Via del Campo, Ste 200
				San Diego  CA  92127
				US

D0-C8-57   (hex)		Nanjing Magewell Electronics Co.,Ltd
800000-8FFFFF     (base 16)		Nanjing Magewell Electronics Co.,Ltd
				14th Floor, Building 3, No. 89 Shengli Road, Jiangning Economic and Technological Development Zone
				Nanjing  Jiangsu  211100
				CN

D0-C8-57   (hex)		Dante Security Inc.
C00000-CFFFFF     (base 16)		Dante Security Inc.
				303 MERRICK RD., Unit 208
				LYNBROOK  NY  11563
				US

BC-97-40   (hex)		B4ComTechnologies LLC
E00000-EFFFFF     (base 16)		B4ComTechnologies LLC
				Office 2/6, 16a, Ivana Babushkina street
				Moscow    117292
				RU

BC-97-40   (hex)		Amap Information Technology Co., Ltd
A00000-AFFFFF     (base 16)		Amap Information Technology Co., Ltd
				A051, No.01, 3/F, No.55 Suzhou Street, Haidian District
				Beijing  Beijing  100080
				CN

BC-97-40   (hex)		LISTEC GmbH
C00000-CFFFFF     (base 16)		LISTEC GmbH
				Am Sandberg 34
				Isen  Bavaria  84424
				DE

D0-C8-57   (hex)		YUAN High-Tech Development Co., Ltd.
000000-0FFFFF     (base 16)		YUAN High-Tech Development Co., Ltd.
				18F, No.88, Sec. 2, Chung Hsiao E.Rd., 
				Taipei,   Taiwan   10050 
				TW

BC-97-40   (hex)		Wind Mobility Technology (Beijing) Co., Ltd
400000-4FFFFF     (base 16)		Wind Mobility Technology (Beijing) Co., Ltd
				13603, Building 13, No. 2, Nanzhuzhang Hutong, Dongcheng District
				Beijing  Beijing  100010
				CN

60-95-CE   (hex)		Q-SENTECH Co.,Ltd.
200000-2FFFFF     (base 16)		Q-SENTECH Co.,Ltd.
				#201,170 Seonyu-ro, Yeongdeungpo-gu
				Seoul  Korea  07255
				KR

1C-82-59   (hex)		Microtronics Engineering GmbH
E00000-EFFFFF     (base 16)		Microtronics Engineering GmbH
				Hauptstrasse 7
				Ruprechtshofen    3244
				AT

1C-82-59   (hex)		Diatrend Corporation
200000-2FFFFF     (base 16)		Diatrend Corporation
				Grand Front Osaka Tower-B 28F, 3-1 ofuka-cho, kita-ku
				Osaka  Osaka  530-0011
				JP

1C-82-59   (hex)		SHENZHEN AOA TECHNOLOGY CO.,LTD
800000-8FFFFF     (base 16)		SHENZHEN AOA TECHNOLOGY CO.,LTD
				B624,C1 Building,Hengchao Industrial Park,Tangtou Road,Shiyan,Bao'an District
				SHENZHEN  Guangdong  518108
				CN

84-8B-CD   (hex)		WORMIT
C00000-CFFFFF     (base 16)		WORMIT
				Sec.1,Xintai 5th Rd.,Xizhi Dist.
				New Taipei City    22101
				TW

B0-FD-0B   (hex)		Taian Yuqi Communication Technology Co., Ltd
500000-5FFFFF     (base 16)		Taian Yuqi Communication Technology Co., Ltd
				Building 4, Fengxiang Road, Tai'an Development Zone
				Tai’an  Shandong  271000
				CN

B0-FD-0B   (hex)		Eagle Acoustics Manufacturing, LLC 
900000-9FFFFF     (base 16)		Eagle Acoustics Manufacturing, LLC 
				333 E IL ROUTE 83, Ste. 100
				MUNDELEIN  IL  60060-4214
				US

1C-82-59   (hex)		Shanghai Xiaoyan Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shanghai Xiaoyan Technology Co., Ltd.
				Room 503, Building B, NO. 2305, Zuchongzhi Road
				Shanghai  Shanghai  201203
				CN

84-8B-CD   (hex)		Logic Supply
400000-4FFFFF     (base 16)		Logic Supply
				35 Thompson St
				South Burlington  VT  05403
				US

B0-FD-0B   (hex)		Everynet Oy
700000-7FFFFF     (base 16)		Everynet Oy
				At Azets Insight Oy, Hatanpään valtatie 26 (5.krs)
				Tampere    33100
				FI

B0-FD-0B   (hex)		Vista Manufacturing
200000-2FFFFF     (base 16)		Vista Manufacturing
				53345 Columbia Drive
				Elkhart  IN  46514
				US

8C-14-7D   (hex)		Private
100000-1FFFFF     (base 16)		Private

C8-2C-2B   (hex)		RF Engineering and Energy Resource
300000-3FFFFF     (base 16)		RF Engineering and Energy Resource
				4460 Commercial Ave.
				Portage  MI  49002
				US

C8-2C-2B   (hex)		iWave Systems Tech Pvt Ltd
400000-4FFFFF     (base 16)		iWave Systems Tech Pvt Ltd
				7/B 29th Main, BTM Layout 2nd Stage
				Bengalore  Kamataka  560076
				IN

C8-2C-2B   (hex)		DALCO AG
500000-5FFFFF     (base 16)		DALCO AG
				Industriestr. 28
				Volketswil  ZH  8604
				CH

1C-CA-E3   (hex)		Private
F00000-FFFFFF     (base 16)		Private

C8-63-14   (hex)		Optictimes Co.,Ltd
A00000-AFFFFF     (base 16)		Optictimes Co.,Ltd
				Hangzhou City,  Zhejiang Province
				Hangzhou  Zhejiang  310023
				CN

E4-1E-0A   (hex)		Tritium Pty Ltd
700000-7FFFFF     (base 16)		Tritium Pty Ltd
				1/31 Archimedes PL.
				Murarrie  QLD   4172
				AU

E4-1E-0A   (hex)		Zavod № 423
000000-0FFFFF     (base 16)		Zavod № 423
				2B, Zavodskoy proezd
				Bogoroditsk  Tula  301830
				RU

CC-D3-9D   (hex)		Shanghai tongli information technology co. LTD
E00000-EFFFFF     (base 16)		Shanghai tongli information technology co. LTD
				Floor 2, building 1, liqin building, No.1885, metropolis road, minhang district
				Shanghai  Shanghai  201108
				CN

E4-1E-0A   (hex)		Aeroel srl
500000-5FFFFF     (base 16)		Aeroel srl
				Vai Pier Paolo Pasolini 35/3
				Pradamano  Udine  33040
				IT

FC-D2-B6   (hex)		Winglet Systems Inc.
900000-9FFFFF     (base 16)		Winglet Systems Inc.
				4-6, Shinyokohama 2-chome, Kohoku-ku
				 Yokohama  Kanagawa  222-0033
				JP

34-E1-D1   (hex)		CREW by True Rowing, Inc.
C00000-CFFFFF     (base 16)		CREW by True Rowing, Inc.
				14 Arrow St, Floor 4
				Cambridge  MA  02138
				US

34-E1-D1   (hex)		SAMA NextGen PTE Limited
100000-1FFFFF     (base 16)		SAMA NextGen PTE Limited
				  16 Collyer Quay, #21-00 Income AT Raffels,  Singapore 049318
				Singapore    049318
				SG

34-E1-D1   (hex)		HI-TECH.ORG
D00000-DFFFFF     (base 16)		HI-TECH.ORG
				Volgogradskiy prospekt, 43, k.3, room XXVI
				Moscow     109316
				RU

D4-7C-44   (hex)		Huaqin Telecom Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Huaqin Telecom Technology Co.,Ltd.
				Building 1,No.399, Keyuan Road, Pudong, Shanghai China
				Shanghai    200120
				CN

FC-D2-B6   (hex)		Soma GmbH
200000-2FFFFF     (base 16)		Soma GmbH
				Gewerbering 9
				Schalksmühle  NRW  58579
				DE

E4-4C-C7   (hex)		Beijing Zhongchuangwei Nanjing Quantum Communication Technology Co., Ltd.
400000-4FFFFF     (base 16)		Beijing Zhongchuangwei Nanjing Quantum Communication Technology Co., Ltd.
				No. 88, pubin avenue, jiangpu street, pukou district, nanjing city
				nanjing  Jiangsu  210000
				CN

E4-4C-C7   (hex)		Alert Alarm AB
000000-0FFFFF     (base 16)		Alert Alarm AB
				Råsundavägen 4
				Solna  Stockholm  16967
				SE

4C-BC-98   (hex)		Shenzhen Shanling Digital Technology Development Co.,Ltd.
800000-8FFFFF     (base 16)		Shenzhen Shanling Digital Technology Development Co.,Ltd.
				No.10, Chiwan 1 Road, Shekou, Nanshan
				Shenzhen  GuangDong  518068
				CN

E4-4C-C7   (hex)		JSC Svyaz Inginiring M
300000-3FFFFF     (base 16)		JSC Svyaz Inginiring M
				Varshavskoe Shosse, 42
				Moscow    115230
				RU

4C-BC-98   (hex)		Nemon Co., Ltd.
400000-4FFFFF     (base 16)		Nemon Co., Ltd.
				B-834, 164 Tancheonsangro, Bundang
				Seongnam  Gyeonggi  13631
				KR

E0-5A-9F   (hex)		ShenZhen Arts Changhua Intelligent Technology Co., Ltd
E00000-EFFFFF     (base 16)		ShenZhen Arts Changhua Intelligent Technology Co., Ltd
				15i, Taibang Science & Technology Building, Science and Technology South 8th Road, Hi-Tech Park South Area
				Shenzhen  Guangdong  518057
				CN

8C-C8-F4   (hex)		Private
700000-7FFFFF     (base 16)		Private

98-02-D8   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D8-86-0B   (hex)		Get SAT
200000-2FFFFF     (base 16)		Get SAT
				Hamada 12
				Rehovot  Select From Dropdown  7670316
				IL

E0-5A-9F   (hex)		OMB Guitars LLC
700000-7FFFFF     (base 16)		OMB Guitars LLC
				24 Hazorim St
				Efrat  Jerusalem  90435
				IL

E0-5A-9F   (hex)		AITEC SYSTEM CO., LTD.
100000-1FFFFF     (base 16)		AITEC SYSTEM CO., LTD.
				466-1 Aoto-cho, Midori-ku
				Yokohama-shi  Kanagawa  226-0022
				JP

C4-FF-BC   (hex)		viRaTec GmbH
E00000-EFFFFF     (base 16)		viRaTec GmbH
				Phorusgasse 8/1
				Wien    1040
				AT

38-B1-9E   (hex)		Basalte BVBA
400000-4FFFFF     (base 16)		Basalte BVBA
				Hundelgemsesteenweg 1a
				Merelbeke    9820
				BE

CC-D3-9D   (hex)		Continental Control Systems
200000-2FFFFF     (base 16)		Continental Control Systems
				2150 Miller Drive  Suite A
				Longmont  CO  80501
				US

CC-D3-9D   (hex)		Hangzhou Scooper Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Hangzhou Scooper Technology Co.,Ltd.
				Room706,707,5th,No.998,Wenyi West Raod,Wuchang Street,Yuhang District,Hangzhou
				HangZhou  ZheJiang  311121
				CN

CC-D3-9D   (hex)		INX CO.,LTD.
000000-0FFFFF     (base 16)		INX CO.,LTD.
				6F Nippatsu Nishiguchi Bldg 3-32-1 Tsuruya-cho Kanagawa-ku
				Yokohama-shi  Kanagawa  221-0835
				JP

D4-25-CC   (hex)		Nanjing LES Information Technology Co., Ltd
600000-6FFFFF     (base 16)		Nanjing LES Information Technology Co., Ltd
				No.8,YongZhi Road
				Nanjing  Jiangsu  210014
				CN

D4-25-CC   (hex)		Veea
B00000-BFFFFF     (base 16)		Veea
				164 E183rd street
				New York  NY  10028
				US

D4-25-CC   (hex)		Combined Energy Technologies Pty Ltd
D00000-DFFFFF     (base 16)		Combined Energy Technologies Pty Ltd
				19 The Avenue
				Newport  NSW  2106
				AU

9C-69-B4   (hex)		Globalcom Engineering SPA
400000-4FFFFF     (base 16)		Globalcom Engineering SPA
				Via Volta 9
				MORNAGO  VA  21020
				IT

4C-91-7A   (hex)		Inster Tecnología y Comunicaciones SAU
100000-1FFFFF     (base 16)		Inster Tecnología y Comunicaciones SAU
				Avda. Rita Levi Montalcini, 2 Parcela 5, Tecnogetafe - Getafe
				Madrid    28906
				ES

4C-91-7A   (hex)		S.I.C.E.S. srl
700000-7FFFFF     (base 16)		S.I.C.E.S. srl
				Via Molinello, 8B
				Jerago con Orago  VARESE  21040
				IT

9C-69-B4   (hex)		MOZI (Shenzhen) Artificial Intelligence Technology Co., Ltd. 
200000-2FFFFF     (base 16)		MOZI (Shenzhen) Artificial Intelligence Technology Co., Ltd. 
				Room 1305, Building A Phase I Innovation and Technology Square, 4 Tairan Road, Futian
				 Shenzhen   Guangdong  518000
				CN

9C-69-B4   (hex)		Appareo Systems, LLC
300000-3FFFFF     (base 16)		Appareo Systems, LLC
				1830 NDSU Research Circle N
				Fargo  ND  58102
				US

6C-DF-FB   (hex)		Guilin Zhishen Information TechonlogyCO.,Ltd
A00000-AFFFFF     (base 16)		Guilin Zhishen Information TechonlogyCO.,Ltd
				Creative Industrial Park,GuiMo Rd.,Qi Xing
				Guilin  Guangxi  541004
				CN

6C-DF-FB   (hex)		Greenbird Vertriebs GmbH
500000-5FFFFF     (base 16)		Greenbird Vertriebs GmbH
				Georg Sigl-Straße 40-42
				Breitenfurt bei Wien  Niederösterreich  2384
				AT

0C-EF-AF   (hex)		Private
F00000-FFFFFF     (base 16)		Private

6C-DF-FB   (hex)		Toucan Systems Ltd
C00000-CFFFFF     (base 16)		Toucan Systems Ltd
				3 Roseheyworth Business Park
				Abertillery  Bleanau Gwent  NP13 1SP
				GB

98-F9-C7   (hex)		Promess GmbH
400000-4FFFFF     (base 16)		Promess GmbH
				Schaffhausener Str. 44
				Berlin    12099
				DE

98-F9-C7   (hex)		Renalsense
800000-8FFFFF     (base 16)		Renalsense
				Hamarpe 3
				Jerusalem    9777403
				IL

98-F9-C7   (hex)		SHENZHEN HUNTKEY ELECTRIC CO., LTD.
000000-0FFFFF     (base 16)		SHENZHEN HUNTKEY ELECTRIC CO., LTD.
				Huntkey Industrial Park, Xue-Xiang Village, Bantian, Longgang District,
				Shenzhen  Guangdong  518129
				CN

98-F9-C7   (hex)		HighSecLabs
100000-1FFFFF     (base 16)		HighSecLabs
				29 Haeshel St
				Caesarea    3088900
				IL

0C-FE-5D   (hex)		CTK Contact Electronics co., Ltd.
800000-8FFFFF     (base 16)		CTK Contact Electronics co., Ltd.
				6F-5, No79, Sec 1, Xintai 5th RD, Xizhi Dist
				New Taipei City    22101
				TW

0C-FE-5D   (hex)		Fujian Jieyu Computer Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Fujian Jieyu Computer Technology Co., Ltd.
				3rd Floor, Building 21, Cangshan Park, Jinshan Orange Garden Industrial Park, Cangshan District
				Fuzhou  Fujian  350000 
				CN

A4-58-0F   (hex)		Homebeaver
C00000-CFFFFF     (base 16)		Homebeaver
				3 place ville marie, 4th floor
				Montreal  Quebec  H3B 2E3
				CA

6C-5C-3D   (hex)		Clinton Electronics Corporation
E00000-EFFFFF     (base 16)		Clinton Electronics Corporation
				6701 Clinton Road
				Loves Park  IL  61111
				US

0C-FE-5D   (hex)		Dspread International Co.,Limited
200000-2FFFFF     (base 16)		Dspread International Co.,Limited
				 UNIT 402. 4/F FAIRMONT HSE NO.8 COTTON TREE DRIVE ADMIRALTY
				HONG KONG  HONG KONG  999077
				HK

1C-FD-08   (hex)		sunweit industrial limited
700000-7FFFFF     (base 16)		sunweit industrial limited
				Block A ,503B Room,Zhihui Innovation Centre
				Shenzhen  GUANGDONG  518000
				CN

1C-FD-08   (hex)		InSeat Solutions, LLC
000000-0FFFFF     (base 16)		InSeat Solutions, LLC
				1871 Wright Avenue
				La Verne  CA  91750
				US

1C-FD-08   (hex)		guangzhou huiqun intelligent technology co. LTD
B00000-BFFFFF     (base 16)		guangzhou huiqun intelligent technology co. LTD
				room 502, building 2, no. 6, haijing road, xinzao town, panyu district
				guangzhou  guangdong  511436
				CN

1C-FD-08   (hex)		SABIK Offshore GmbH
400000-4FFFFF     (base 16)		SABIK Offshore GmbH
				Wilhelm-Maybach-Straße 3
				Schwerin  Mecklenburg-Vorpommern  D-19061
				DE

1C-FD-08   (hex)		HiHi Ltd
200000-2FFFFF     (base 16)		HiHi Ltd
				Loewy House 11 Enterprise Way
				Christchurch    BH236EW
				GB

1C-FD-08   (hex)		Umeox Innovations Co.,Ltd
300000-3FFFFF     (base 16)		Umeox Innovations Co.,Ltd
				Room 1208-09, Research Building, Tsinghua Information Port, No. 1, Xindong Road, Nanshan District, Shenzhen
				Shenzhen  Guangdong  518000
				CN

6C-5C-3D   (hex)		Hangzhou Netease Yanxuan Trading Co.,Ltd
600000-6FFFFF     (base 16)		Hangzhou Netease Yanxuan Trading Co.,Ltd
				Room 410,No.4 Building,No.599 Road Wangshang, 
				Hangzhou, Binjiang District,  Zhejiang Province  310052
				CN

6C-5C-3D   (hex)		Shenzhen Justek Technology Co., Ltd
100000-1FFFFF     (base 16)		Shenzhen Justek Technology Co., Ltd
				5/F, Building No.818, Qingtiexi Mabu Community, Bao 'an DistrictXixiang Street,
				Shenzhen  Guangdong  518102
				CN

3C-6A-2C   (hex)		Beijing Donghua Hongtai Polytron Technologies Inc
E00000-EFFFFF     (base 16)		Beijing Donghua Hongtai Polytron Technologies Inc
				Room 126,Layer 1, Mudan building, , Huayuan Road No. 2, Haidian District
				Beijing  Beijing  100089
				CN

D0-22-12   (hex)		Private
F00000-FFFFFF     (base 16)		Private

CC-1B-E0   (hex)		Private
F00000-FFFFFF     (base 16)		Private

3C-6A-2C   (hex)		Homegear GmbH
700000-7FFFFF     (base 16)		Homegear GmbH
				Am Schützenplatz 3
				Preetz  Schleswig-Holstein  24211
				DE

30-0A-60   (hex)		Sixth Energy Technologies Private Limited
D00000-DFFFFF     (base 16)		Sixth Energy Technologies Private Limited
				#62, Sri Varda, 10th main, HMT Layout, R.T.Nagar
				Bangalore  Karnataka  560032
				IN

3C-6A-2C   (hex)		Rio Lago Technologies  LLC
000000-0FFFFF     (base 16)		Rio Lago Technologies  LLC
				17741 Ludlow St.
				Granada Hills  CA  91344-4502
				US

30-0A-60   (hex)		Private
300000-3FFFFF     (base 16)		Private

30-0A-60   (hex)		KAZUtechnica Co.,Ltd.
000000-0FFFFF     (base 16)		KAZUtechnica Co.,Ltd.
				1-9-18,Chuo,Chuo-ku
				Sagamihara-shi  Kanagawa  2520239
				JP

30-0A-60   (hex)		A9
500000-5FFFFF     (base 16)		A9
				27,BUCHEON-RO 198BEON-GIL
				BUCHEON-SI  GYEONGGI-DO  14555
				KR

30-0A-60   (hex)		Imageo s.r.o.
E00000-EFFFFF     (base 16)		Imageo s.r.o.
				Golcova 485
				Praha    14800
				CZ

3C-6A-2C   (hex)		La Barrière Automatique
600000-6FFFFF     (base 16)		La Barrière Automatique
				451 chemin de Champivost
				Limonest    69760
				FR

74-E1-4A   (hex)		Private
F00000-FFFFFF     (base 16)		Private

C8-8E-D1   (hex)		Private
F00000-FFFFFF     (base 16)		Private

A4-ED-43   (hex)		Heyuan intelligence technology CO.,Ltd
900000-9FFFFF     (base 16)		Heyuan intelligence technology CO.,Ltd
				No.1166 Xinluo Street
				Jinan City  Shandong Province  250101
				CN

A0-28-33   (hex)		JGR Optics Inc
500000-5FFFFF     (base 16)		JGR Optics Inc
				160 Michael Cowpland Drive
				Ottawa  Ontario  K2M 1P6
				CA

A0-28-33   (hex)		Firm INFORMTEST Ltd.
400000-4FFFFF     (base 16)		Firm INFORMTEST Ltd.
				APT. 8, LODG. XIV ,FL.6, bld.4, Passage Savelkinsky
				Zelenograd  Moscow  124482
				RU

A0-28-33   (hex)		Kryptus Information Security S/A
700000-7FFFFF     (base 16)		Kryptus Information Security S/A
				Rua Maria Tereza Dias da Silva 270
				Cidade Universitaria  Campinas-SP  CEP 13083-820
				BR

A0-28-33   (hex)		IMESHX CORPORATION LIMITED
900000-9FFFFF     (base 16)		IMESHX CORPORATION LIMITED
				10A7F, ShenZhen Bay Technology Ecological Park, NanShan District,
				Shenzhen  Guangdong  518000
				CN

9C-F6-DD   (hex)		Savari Inc
800000-8FFFFF     (base 16)		Savari Inc
				2005 De la cruz blvd, st 111,
				santa clara  CA  95050
				US

30-09-F9   (hex)		Beijing Mydreamplus Information Technology Co., Ltd.
600000-6FFFFF     (base 16)		Beijing Mydreamplus Information Technology Co., Ltd.
				Room 301-2, North Building, No. 11, CangJingGuan Lane, DongCheng District,
				Beijing  Beijing  100005
				CN

84-89-EC   (hex)		Newell Brands
A00000-AFFFFF     (base 16)		Newell Brands
				221 River Street
				Hoboken  NJ  07030
				US

84-89-EC   (hex)		EPSa Elektronik & Präzisionsbau Saalfeld GmbH
B00000-BFFFFF     (base 16)		EPSa Elektronik & Präzisionsbau Saalfeld GmbH
				Remschuetzer Str. 1
				Saalfeld/Saale    07318
				DE

30-09-F9   (hex)		Shenzhen Sunvell Electronics Co., Ltd.
100000-1FFFFF     (base 16)		Shenzhen Sunvell Electronics Co., Ltd.
				5th Floor, Building F, Hongzhu Yongqi Technology Park, Lezhujiao Village, Xixiang Town, Bao’ an District,
				Shenzhen  GuangDong  518000
				CN

30-09-F9   (hex)		Shenzhen Tencent Computer System Co., Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Tencent Computer System Co., Ltd.
				5-10 Building High-tech Zone, Nanshan District, 
				Shenzhen  Guangdong Province  518057
				CN

30-09-F9   (hex)		essence security
800000-8FFFFF     (base 16)		essence security
				Aba Even 12 st 
				Herzelia    4672530
				IL

30-09-F9   (hex)		Maytronics Ltd.
700000-7FFFFF     (base 16)		Maytronics Ltd.
				Kibbutz Yizrael
				Kibbutz Yizrael    1935000
				IL

30-09-F9   (hex)		VELSITEC-CLIBASE
500000-5FFFFF     (base 16)		VELSITEC-CLIBASE
				LA RATELIERE
				SAINT-JUST-MALMONT  Haute-Loire  43240
				FR

C0-83-59   (hex)		Shenzhen Pay Device Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen Pay Device Technology Co., Ltd.
				Room 502,Peng’s Building,Fanshen Road,43# Baoan District
				Shenzhen  Guangdong  518101
				CN

9C-F6-DD   (hex)		RYEEX Technology Co.,Ltd.
300000-3FFFFF     (base 16)		RYEEX Technology Co.,Ltd.
				RM106,Joinin Hub,Builing J District 71,Construction Industrial Park,Xin'an Street,Bao'an, Shenzhen,China
				SHENZHEN  GUANGDONG  518101
				CN

9C-F6-DD   (hex)		Lighting New Energy Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Lighting New Energy Technology Co., Ltd.
				Room 402, Building 22, Chentian Industrial Zone, Xixiang Street, Bao'an District,
				Shenzhen  Guangdong  518100
				CN

C0-83-59   (hex)		Cyber Sciences, Inc.
E00000-EFFFFF     (base 16)		Cyber Sciences, Inc.
				229 Castlewood Dr, Suite E
				Murfreesboro  TN  37129
				US

C0-83-59   (hex)		Private
C00000-CFFFFF     (base 16)		Private

C0-83-59   (hex)		Huaxin SM Optics Co. LTD.
200000-2FFFFF     (base 16)		Huaxin SM Optics Co. LTD.
				5F,B8,Tianfu software Park,Tianfu Road
				Chengdu  Sichuan  610041
				CN

04-C3-E6   (hex)		Flintec UK Ltd.
B00000-BFFFFF     (base 16)		Flintec UK Ltd.
				W4/5 Capital Point, Wentloog Avenue
				Cardiff  Cardiff  CF3 2PW
				GB

3C-42-7E   (hex)		Grandway Technology (Shenzhen) Limited
000000-0FFFFF     (base 16)		Grandway Technology (Shenzhen) Limited
				Block 7, Zhu Keng Industrial Zone
				Ping Shan District  Shenzhen  518118
				CN

04-C3-E6   (hex)		Ekin Teknoloji San ve Tic A.S.
900000-9FFFFF     (base 16)		Ekin Teknoloji San ve Tic A.S.
				maden mah. gediz. sok. no:7, sariyer
				istanbul    34450
				TR

04-C3-E6   (hex)		Invasys
500000-5FFFFF     (base 16)		Invasys
				Sochorova 36
				Brno    616 00
				CZ

04-C3-E6   (hex)		Extech Electronics Co., LTD.
300000-3FFFFF     (base 16)		Extech Electronics Co., LTD.
				17F., No.237, Sec. 1, Datong Rd., Xizhi Dist.
				New Taipei City    22161
				TW

C0-83-59   (hex)		Viper Design, LLC
500000-5FFFFF     (base 16)		Viper Design, LLC
				125 Glancy St.
				Goodlettsville  TN  37072
				US

B4-4B-D6   (hex)		Qstar Technology Co,Ltd 
900000-9FFFFF     (base 16)		Qstar Technology Co,Ltd 
				311# Xindongxing Business Centre ,2rd Road liuxian ,Bao'an Shenzhen China
				Shenzhen   Guangdong   518100
				CN

B4-4B-D6   (hex)		CHUNGHSIN INTERNATIONAL ELECTRONICS CO.,LTD.
E00000-EFFFFF     (base 16)		CHUNGHSIN INTERNATIONAL ELECTRONICS CO.,LTD.
				618-2# Gongren West Road,Jiaojiang,
				Taizhou  Zhejiang  317700
				CN

B4-4B-D6   (hex)		Arnouse Digital Devices Corp
800000-8FFFFF     (base 16)		Arnouse Digital Devices Corp
				1983 Marcus Ave, Suite 104
				Lake Success  NY  11042
				US

3C-42-7E   (hex)		Teknoware Oy
400000-4FFFFF     (base 16)		Teknoware Oy
				Ilmarisentie 8
				Lahti    15200
				FI

D4-7C-44   (hex)		Tendzone International Pte Ltd
A00000-AFFFFF     (base 16)		Tendzone International Pte Ltd
				Rm 202, Blk C, Huahan Innovation Park, No.16 Langshan Rd,Nanshan District
				Shenzhen  GuangDong  518057
				CN

D4-7C-44   (hex)		Innoviz Technologies LTD
100000-1FFFFF     (base 16)		Innoviz Technologies LTD
				Atir Yeda 15
				Kfar Saba  Ha Sharon  4464312
				IL

D4-7C-44   (hex)		Exafore Oy
000000-0FFFFF     (base 16)		Exafore Oy
				Hermiankatu 6-8D
				Tampere    33720
				FI

D4-7C-44   (hex)		OMRON SENTECH CO., LTD.
300000-3FFFFF     (base 16)		OMRON SENTECH CO., LTD.
				9F, Ebina Prime Tower, 9-50, Chuo 2 Chome
				Ebina-City  Kanagawa  243-0432
				JP

2C-48-35   (hex)		Rheonik Messtechnik GmbH
200000-2FFFFF     (base 16)		Rheonik Messtechnik GmbH
				Rudolf-Diesel-Str., 5
				Odelzhausen  Deutschland  85235
				DE

A0-19-B2   (hex)		Adomi
A00000-AFFFFF     (base 16)		Adomi
				777 Mariners Island Blvd. Suite 150
				San Mateo  CA  94404
				US

A0-19-B2   (hex)		Osatec
400000-4FFFFF     (base 16)		Osatec
				15 Parkovaya
				Moscow    105203
				WS

A0-19-B2   (hex)		Lon Microsystems Inc.
900000-9FFFFF     (base 16)		Lon Microsystems Inc.
				11F Ali center Tianfu four street 
				chengdu  sichuan  610041
				CN

2C-48-35   (hex)		SureFlap Ltd
900000-9FFFFF     (base 16)		SureFlap Ltd
				7 The Irwin Centre, Scotland Road, Dry Drayton
				Cambridge  Cambridgeshire  CB23 8AR
				GB

CC-D3-1E   (hex)		ShenZhenBoryNet Co.,LTD.
E00000-EFFFFF     (base 16)		ShenZhenBoryNet Co.,LTD.
				building 9.C-18-n,baoneng tech.park qingxiang road longhua district,shenzhen
				shenzhen  guangzhou  518109
				CN

2C-48-35   (hex)		Santec Corporation
C00000-CFFFFF     (base 16)		Santec Corporation
				5823 Ohkusa-Nenjozaka
				Komaki  Aichi  485-0802
				JP

2C-48-35   (hex)		Exertus Oy
600000-6FFFFF     (base 16)		Exertus Oy
				Kampusranta 9 C
				Seinäjoki    60320
				FI

8C-1C-DA   (hex)		Alcidae Inc
C00000-CFFFFF     (base 16)		Alcidae Inc
				535 Mission St, 14th Fl,
				San Francisco  CA  94105
				US

8C-1C-DA   (hex)		Electronic Controlled Systems, Inc.
E00000-EFFFFF     (base 16)		Electronic Controlled Systems, Inc.
				11200 Hampshire Ave South
				Bloomington  MN  55438
				US

8C-1C-DA   (hex)		LocoLabs LLC
600000-6FFFFF     (base 16)		LocoLabs LLC
				3350 Scott Blvd, Bldg 56
				Santa Clara  CA  95054
				US

3C-24-F0   (hex)		Wisycom
300000-3FFFFF     (base 16)		Wisycom
				Via Spin 156
				Romano D'Ezzelino  Vicenza  36060
				IT

3C-24-F0   (hex)		SHENZHEN PINSIDA TECHNOLOGY CO.,LTD.
000000-0FFFFF     (base 16)		SHENZHEN PINSIDA TECHNOLOGY CO.,LTD.
				411,4/F,Building A,Pengnian Science Park,Honghua IV Road,Xili,Nanshan District
				Shenzhen  Guangdong  518000
				CN

0C-73-EB   (hex)		Shenzhen Samchung Video Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Shenzhen Samchung Video Technology Co., Ltd.
				Xixiang Street 4016 Bao'an Avenue 
				Yong Kai Business Building A,  Bao'an District of Shenzhen City Guangdong  528470
				CN

8C-1C-DA   (hex)		GEOMC
200000-2FFFFF     (base 16)		GEOMC
				Suite514, 130, Digital-ro
				Seoul    08589
				KP

3C-24-F0   (hex)		Laipac Technology Inc.
200000-2FFFFF     (base 16)		Laipac Technology Inc.
				20 Mural St. Unit 5
				Richmond Hill  ON - Ontario  L4B 1K3
				CA

3C-24-F0   (hex)		Inter-Coastal Electronics
400000-4FFFFF     (base 16)		Inter-Coastal Electronics
				5750 E McKellips Rd
				Mesa  AZ  85215
				US

0C-73-EB   (hex)		Beijing L&S Lancom Platform Tech. Co., Ltd. 
900000-9FFFFF     (base 16)		Beijing L&S Lancom Platform Tech. Co., Ltd. 
				1st Floor, Xingtianhaiyuan Building, Xianghuangqi Eaast Rd, Nondda South Rd,Haidian District
				Beijing    100193
				CN

0C-73-EB   (hex)		EVERSEC TECHNOLOGY CORPORATION
100000-1FFFFF     (base 16)		EVERSEC TECHNOLOGY CORPORATION
				F5,Tower D,JingYi Technology Building NO.9 Dazhongsi East Road.,Beijing,P.R.China
				BEIJING  BEIJING  100086
				CN

0C-73-EB   (hex)		Beijing Miiiw Technology Co., Ltd
800000-8FFFFF     (base 16)		Beijing Miiiw Technology Co., Ltd
				Room 3008, 3rd Floor, Qunfang Building, Bowangyuan, Yangfangdian Rd, Haidian District
				Beijing    100010
				CN

48-0B-B2   (hex)		XIAMEN RONGTA TECHNOLOGY CO.,LTD.
A00000-AFFFFF     (base 16)		XIAMEN RONGTA TECHNOLOGY CO.,LTD.
				3F, E Plant, Gaoqi Industrial Zones, No.195, Gaoqi Community, Gaodian Village, Huli
				Xiamen    361000
				CN

48-0B-B2   (hex)		Beijing Dragon Resources Limited.
700000-7FFFFF     (base 16)		Beijing Dragon Resources Limited.
				Tongjunzhuangxinlukou (500meters east) Shilipu Town, MiyunCountry, Beijing101500, China
				BeiJing    101500
				CN

48-0B-B2   (hex)		Thales CETCA Avionics CO., Ltd
200000-2FFFFF     (base 16)		Thales CETCA Avionics CO., Ltd
				NO.9 Baichuan road,Hi-tech industry west zone park, Chengdu, Sichuan
				Chengdu  Sichuan  611731
				CN

88-5F-E8   (hex)		Inor Process AB
C00000-CFFFFF     (base 16)		Inor Process AB
				Travbanegatan 10
				Malmo  Skane  SE-213 77
				SE

88-5F-E8   (hex)		Beijing laiwei Technology  Co.,Ltd
400000-4FFFFF     (base 16)		Beijing laiwei Technology  Co.,Ltd
				Room 205,2/F,No.1 Fazhan Road Beijing information international base Huilongguan town Changping district Beijing
				Beijing  Beijing  102206
				CN

88-5F-E8   (hex)		zhejiang yuanwang communication technolgy co.,ltd
D00000-DFFFFF     (base 16)		zhejiang yuanwang communication technolgy co.,ltd
				No. 6 of shen shi lei lu Road
				ZhuJi  Zhejiang  311800
				CN

B8-D8-12   (hex)		Visual Productions BV
800000-8FFFFF     (base 16)		Visual Productions BV
				Rollandstraat 55ZW
				Haarlem    2013SM
				NL

30-1F-9A   (hex)		NCM Supplies, Inc.
400000-4FFFFF     (base 16)		NCM Supplies, Inc.
				8125 NW 64th Street
				Miami  FL  33166
				US

30-1F-9A   (hex)		Triax A/S
700000-7FFFFF     (base 16)		Triax A/S
				Bjornkaervej 3
				Hornsyld  Denmark  8783
				DK

F0-41-C8   (hex)		POSTIUM KOREA CO., LTD.
800000-8FFFFF     (base 16)		POSTIUM KOREA CO., LTD.
				A208 Samsong Techno Valley, 140 Tongil-ro, Deogyang-gu
				Koyang-si  Kyeonggi-do  10594
				KR

30-1F-9A   (hex)		Origami Group Limited
C00000-CFFFFF     (base 16)		Origami Group Limited
				Unit 913, 9/F.,Tower 2 Cheung Sha Wan Plaza, 833 Cheung Sha Wan Road, Kowloon
				Hong Kong    000000
				HK

30-1F-9A   (hex)		Shenzhen Fengliyuan Energy Conservating Technology Co. Ltd
E00000-EFFFFF     (base 16)		Shenzhen Fengliyuan Energy Conservating Technology Co. Ltd
				8th floor of building A, Baoshan Industrial Estate, Longhua District, Shenzhen
				Shenzhen  Guangdong  518131
				CN

F0-41-C8   (hex)		LINPA ACOUSTIC TECHNOLOGY CO.,LTD 
000000-0FFFFF     (base 16)		LINPA ACOUSTIC TECHNOLOGY CO.,LTD 
				2A,No60 , Lizhong Road,DaliQingxi Town
				Dongguan  Guandong  523648
				CN

88-A9-A7   (hex)		Honeywell spol. s.r.o. HTS CZ o.z. 
200000-2FFFFF     (base 16)		Honeywell spol. s.r.o. HTS CZ o.z. 
				Turanka 100/1387 
				Brno    62700
				CZ

88-A9-A7   (hex)		TWK-ELEKTRONIK
B00000-BFFFFF     (base 16)		TWK-ELEKTRONIK
				Heinrichstr. 85
				Duesseldorf    40239
				DE

88-A9-A7   (hex)		AndroVideo Inc.
C00000-CFFFFF     (base 16)		AndroVideo Inc.
				2f-4, 17, Lane 91, Nei Hu Rd., Sec. 1
				Taipei    11441
				TW

F0-41-C8   (hex)		XI'AN MEI SHANG MEI WIRELESS TECHNOLOGY.Co., Ltd.
500000-5FFFFF     (base 16)		XI'AN MEI SHANG MEI WIRELESS TECHNOLOGY.Co., Ltd.
				Xi'an Beilin District Yanta Middle Road No. 17A XIN QING YA YUAN 2-5C
				XI'AN  shanxi  710000
				CN

88-A9-A7   (hex)		FlashForge Corporation
900000-9FFFFF     (base 16)		FlashForge Corporation
				 No.518, Xianyuan Road
				Jinhua  Zhejiang  321000
				CN

A4-DA-22   (hex)		AURANEXT
600000-6FFFFF     (base 16)		AURANEXT
				202 quai de clichy
				CLICHY    92110
				FR

DC-E5-33   (hex)		WECAN Solution Inc.
600000-6FFFFF     (base 16)		WECAN Solution Inc.
				71, Yulhadong-ro 8-gil, Dong-gu, Daegu, Republic of Korea
				Daegu    41102
				KR

A4-DA-22   (hex)		Malldon Technology Limited
900000-9FFFFF     (base 16)		Malldon Technology Limited
				607 Longsheng Technology Building, Longhua Dist
				Shenzhen  Guangdong  518000
				CN

88-A9-A7   (hex)		Mikroelektronika
300000-3FFFFF     (base 16)		Mikroelektronika
				Batajnicki drum 23
				Belgrade    11186
				RS

C4-FF-BC   (hex)		Shenzhen C & D Electronics Co., Ltd.
600000-6FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

C4-FF-BC   (hex)		ShenZhen ZYT Technology co., Ltd
800000-8FFFFF     (base 16)		ShenZhen ZYT Technology co., Ltd
				Floor four,Build C,FuSen Industrial park, HangCheng Avenue,Baoan District
				Shenzhen  GuangDong  518000
				CN

C4-FF-BC   (hex)		Beijing  KDF information technology co. LTD.
D00000-DFFFFF     (base 16)		Beijing  KDF information technology co. LTD.
				Room14C,TowerA,,LindaBuilding,No.8,Dongtucheng Road,Chaoyang District, Beijing.
				Beijing    100013
				CN

C4-FF-BC   (hex)		Advanced Navigation
A00000-AFFFFF     (base 16)		Advanced Navigation
				Level 8, 37 Pitt Street
				Sydney  NSW  2000
				AU

C4-FF-BC   (hex)		Mobiletron Electronics Co., Ltd
200000-2FFFFF     (base 16)		Mobiletron Electronics Co., Ltd
				85, Sec.4, Chung-Ching Rd., Ta-Ya District
				Taichung    428
				TW

C4-FF-BC   (hex)		KyongBo Electric Co., Ltd.
C00000-CFFFFF     (base 16)		KyongBo Electric Co., Ltd.
				5, Seongsuil-ro 12-gagil Seongdong-gu
				Seoul    04792
				KR

9C-43-1E   (hex)		ProMOS Technologies Inc.
500000-5FFFFF     (base 16)		ProMOS Technologies Inc.
				3A3, No.1, Lixing 1st Rd., East Dist.,
				Hsinchu City  Taiwan  300
				TW

9C-43-1E   (hex)		Wunda Group plc
800000-8FFFFF     (base 16)		Wunda Group plc
				Unit 1-5, Hawthorn, Crick
				Caldicot  Monmouthshire  NP26 5UT
				GB

9C-43-1E   (hex)		R-S-I Elektrotechnik GmbH  CO KG
600000-6FFFFF     (base 16)		R-S-I Elektrotechnik GmbH  CO KG
				Woelkestrasse 11
				Schweitenkirchen    85276
				DE

9C-43-1E   (hex)		CONTINENT Co. Ltd
900000-9FFFFF     (base 16)		CONTINENT Co. Ltd
				Bumazhnaya st., 16/3 lit B, of. 414
				Saint-Petersburg    190020
				RU

28-2C-02   (hex)		Dexin Digital Technology Corp. Ltd.
300000-3FFFFF     (base 16)		Dexin Digital Technology Corp. Ltd.
				No.10 and 12, Wuxing Fourth Road,Wuhou District Chengdu 610045 Sichuan, PR China
				chengdu  Sichuan  610045
				CN

9C-43-1E   (hex)		Advanced Logic Technology (ALT) sa
300000-3FFFFF     (base 16)		Advanced Logic Technology (ALT) sa
				Route de Niederpallen, 30H
				Redange-sur-Attert  Luxembourg  8506
				LU

F8-B5-68   (hex)		Beijing Wanji Techonology Co., Ltd.
900000-9FFFFF     (base 16)		Beijing Wanji Techonology Co., Ltd.
				NO.12 Building,Zhongguancun Software Park,Haidian District 
				beijing  beijing  100193
				CN

28-2C-02   (hex)		Telecom and Microelectonic Industries
700000-7FFFFF     (base 16)		Telecom and Microelectonic Industries
				1-ja ulica Buhvostova, d.12/11, korp.53, floor 13
				Moscow    107258
				RU

28-2C-02   (hex)		Systec Intelligent Building Technology (Tianjin) Co.,Ltd.
900000-9FFFFF     (base 16)		Systec Intelligent Building Technology (Tianjin) Co.,Ltd.
				Room 1312, Building D, HI-Tech. Information Square, No.8 Huatian Rd., Huayuan HI-Tech. Park
				Tianjin    300384
				CN

F8-B5-68   (hex)		ZAO &quot;RADIUS Avtomatika&quot;
E00000-EFFFFF     (base 16)		ZAO &quot;RADIUS Avtomatika&quot;
				Panfilovskiy prospekt, 10/3
				Zelenograd  Moscow  124489
				RU

28-2C-02   (hex)		Lookman Electroplast Industries Ltd
600000-6FFFFF     (base 16)		Lookman Electroplast Industries Ltd
				Old No : 9, New No : 15, II Street Etn., III Main Road , CIT Nagar, Nandanam
				Chennai  Tamilnadu  600035
				IN

F8-B5-68   (hex)		SinePulse GmbH
A00000-AFFFFF     (base 16)		SinePulse GmbH
				Kistlerhofstr. 170
				Munich    D-81379
				DE

F8-B5-68   (hex)		Shenzhen New-Bund Technology Co., Ltd.
200000-2FFFFF     (base 16)		Shenzhen New-Bund Technology Co., Ltd.
				Room20A, 20th Floor, HSAE Technology Building, Nanshan District,
				 Shenzhen    518000
				CN

F8-B5-68   (hex)		CloudMinds (Shenzhen) Holdings Co., Ltd
700000-7FFFFF     (base 16)		CloudMinds (Shenzhen) Holdings Co., Ltd
				Tower 3, 33F, Unit B, Wangjing SOHO,Wangjing Street No.10
				beijing    100102
				CN

40-48-FD   (hex)		Dorel Juvenile
800000-8FFFFF     (base 16)		Dorel Juvenile
				25 Forbes Blvd
				Foxborough  MA  02035
				US

40-48-FD   (hex)		The 52nd Research Institute of China Electronic Technology Group Corporation
500000-5FFFFF     (base 16)		The 52nd Research Institute of China Electronic Technology Group Corporation
				No.36 Ma Cheng Road,
				Hangzhou  Zhejiang  310012
				CN

40-48-FD   (hex)		BEIJING C&W ELECTRONICS(GROUP)CO.,LTD
000000-0FFFFF     (base 16)		BEIJING C&W ELECTRONICS(GROUP)CO.,LTD
				No.14 Jiuxianqiao,chaoyang,Beijing,China
				Beijing  Beijing  100015
				CN

F8-B5-68   (hex)		3SI Security Systems, Inc
C00000-CFFFFF     (base 16)		3SI Security Systems, Inc
				101 Lindenwood Drive, Suite 200
				Malvern  PA  19355
				US

40-48-FD   (hex)		NOX Systems AG
D00000-DFFFFF     (base 16)		NOX Systems AG
				Alvierweg 17
				Vaduz  FL  9490
				LI

38-73-EA   (hex)		Lightform, Inc.
900000-9FFFFF     (base 16)		Lightform, Inc.
				123 Langton St.
				San Francisco  CA  94103
				US

38-73-EA   (hex)		Live Sentinel
600000-6FFFFF     (base 16)		Live Sentinel
				27 Armthorpe Rd.
				Brampton  Ontario  L6T 5M4
				CA

EC-9F-0D   (hex)		Simula Technology Inc.
100000-1FFFFF     (base 16)		Simula Technology Inc.
				14 F, 1351, Zhong-Zheng Rd.
				Taoyuan     330
				TW

EC-9F-0D   (hex)		Shenzhen Compare Electronics Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen Compare Electronics Co., Ltd
				18F 5D First Area, Shenzhen Bay Eco-tech Park, Nanshan District, Shenzhen 518057, China
				Shenzhen City (深圳市)  Guangdong  518057
				CN

EC-9F-0D   (hex)		Zhejiang HEJU Communication Technology Co., Ltd
800000-8FFFFF     (base 16)		Zhejiang HEJU Communication Technology Co., Ltd
				F4,Block B, Lotus Commercial Building,Lianhua Street 333#,XiHu District
				HANGZHOU  ZHEJIANG  310012
				CN

34-D0-B8   (hex)		OROSOUND SAS
B00000-BFFFFF     (base 16)		OROSOUND SAS
				48 RUE AMELOT
				PARIS    75011
				FR

AC-1D-DF   (hex)		Motec Pty Ltd
400000-4FFFFF     (base 16)		Motec Pty Ltd
				121 Merrindale Drive
				Croydon South  Victoria  3136
				AU

AC-1D-DF   (hex)		Green IT Korea Co., Ltd.
700000-7FFFFF     (base 16)		Green IT Korea Co., Ltd.
				1, Gaun-ro 1-gil, Namyangju-si
				Seoul    12263
				KR

AC-1D-DF   (hex)		Shenzhen Ouzheng Electronic Tech Co,.Ltd
500000-5FFFFF     (base 16)		Shenzhen Ouzheng Electronic Tech Co,.Ltd
				Longgang District Pinghu Street Fangkeng Road No 7 B Building 2nd Floor
				Shenzhen  Guangdong  518111
				CN

CC-22-37   (hex)		shenzhen zonglian network technology limited
A00000-AFFFFF     (base 16)		shenzhen zonglian network technology limited
				floor 3, building 3, yuepeng industry area, guanlan avenue,longhua new district
				shenzhen  guangdong  518000
				CN

CC-22-37   (hex)		E Ink Corp
900000-9FFFFF     (base 16)		E Ink Corp
				1000 Technology Park Drive
				Billerica  MA  01821
				US

74-1A-E0   (hex)		Socionext Inc.
100000-1FFFFF     (base 16)		Socionext Inc.
				Nomura Shin-Yokohama Bldg., 2-10-23 Shin-Yokohama, Kohoku-ku
				Yokohama  Kanagawa  222-0033
				JP

CC-22-37   (hex)		Safilo S.p.A.
800000-8FFFFF     (base 16)		Safilo S.p.A.
				Settima Strada
				Padova    35129
				IT

2C-27-9E   (hex)		Electronique Bluewave Inc.
100000-1FFFFF     (base 16)		Electronique Bluewave Inc.
				5292 Marquette
				Montreal  Qc  H2J 3Z3
				CA

2C-27-9E   (hex)		Exegy Inc
A00000-AFFFFF     (base 16)		Exegy Inc
				349 Marshall Avenue, Suite 100
				Saint Louis    63119
				US

90-4E-91   (hex)		Shanghai JaWay Information Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Shanghai JaWay Information Technology Co., Ltd.
				Rm. 1102, Science and Technology Building A, No. 900 of Yishan Road, Xuhui District,
				Shanghai    200030
				CN

B8-D8-12   (hex)		Glamo Inc.
000000-0FFFFF     (base 16)		Glamo Inc.
				6F Sunshinecity Bunkakaikan,
				Tokyo  Toshima-ku  1708630
				JP

2C-27-9E   (hex)		FOCAL-JMLab
700000-7FFFFF     (base 16)		FOCAL-JMLab
				108 rue de l'Avenir
				La Talaudière    42353
				FR

90-4E-91   (hex)		Teleepoch Ltd
300000-3FFFFF     (base 16)		Teleepoch Ltd
				No.13 Langshan Rd,HiTech Park,Nanshan District
				Shenzhen  Guangdong  518000
				CN

18-9B-A5   (hex)		legendsky tech 
D00000-DFFFFF     (base 16)		legendsky tech 
				RM2210 PENG YUN GE JINGLI MANSION NO.48 BEILI ROAD SOUTH
				ShenZhen    518109
				CN

18-9B-A5   (hex)		SHENZHEN FIONEXX TECHNOLOGIES LTD.
A00000-AFFFFF     (base 16)		SHENZHEN FIONEXX TECHNOLOGIES LTD.
				RM503, The 1st office Bldg, Vanke Red Cube Mansion, Buji Street, Longgang District, 
				shenzhen  Guangdong  518000
				CN

18-9B-A5   (hex)		Beijing Xinertel Technology Co., Ltd.
700000-7FFFFF     (base 16)		Beijing Xinertel Technology Co., Ltd.
				101, Building No.5, No.8 Chuangye Road., Haidian District
				Beijing   Beijing  100085
				CN

90-4E-91   (hex)		Showtacle s.r.o.
C00000-CFFFFF     (base 16)		Showtacle s.r.o.
				Pecnianska 21
				Bratislava  Choose State / Province  85101
				SK

18-9B-A5   (hex)		Taiwan Name Plate Co.,LTD
E00000-EFFFFF     (base 16)		Taiwan Name Plate Co.,LTD
				No.36, Huaya 1st Rd., Guishan Dist., Taoyuan City 33383, Taiwan
				Taoyuan City  Taiwan  33383
				CN

18-9B-A5   (hex)		Starfire Industries LLC
500000-5FFFFF     (base 16)		Starfire Industries LLC
				2109 South Oak St., Suite 100
				Champaign  IL  61820
				US

CC-1B-E0   (hex)		Microtech System,Inc  
000000-0FFFFF     (base 16)		Microtech System,Inc  
				A-1102, Digital Empire Building
				Suwon  Gyeonggi-do  16690
				KR

18-9B-A5   (hex)		Dectris Ltd.
000000-0FFFFF     (base 16)		Dectris Ltd.
				Taefernweg 1
				Baden-Daettwil    5405
				CH

34-29-8F   (hex)		Keystone Electronic Solutions
D00000-DFFFFF     (base 16)		Keystone Electronic Solutions
				469 Julius Jeppe St, Waterkloof
				Pretoria  Gauteng  0181
				ZA

28-F5-37   (hex)		Herbert Waldmann GmbH & Co. KG
900000-9FFFFF     (base 16)		Herbert Waldmann GmbH & Co. KG
				Peter-Henlein-Straße 5
				Villingen-Schwenningen  Baden-Württemberg  78056
				DE

28-F5-37   (hex)		Performance Motion Devices
E00000-EFFFFF     (base 16)		Performance Motion Devices
				1 Technology Park Drive 
				Westford  MA  01886
				US

28-F5-37   (hex)		MyOmega Systems GmbH
600000-6FFFFF     (base 16)		MyOmega Systems GmbH
				Neumeyerstr. 28-34
				Nürnberg  Bavaria  90411
				DE

78-D8-00   (hex)		Björkviks Consulting AB
500000-5FFFFF     (base 16)		Björkviks Consulting AB
				Hällkanavägen 7
				Bro    19791
				SE

78-D8-00   (hex)		Maddalena S.p.A.
B00000-BFFFFF     (base 16)		Maddalena S.p.A.
				via G.B. Maddalena 2/4
				Povoletto  UD  33040
				IT

78-D8-00   (hex)		SightLine Applications
900000-9FFFFF     (base 16)		SightLine Applications
				2828 SW CORBETT AVE
				PORTLAND  OR  97201
				US

7C-BA-CC   (hex)		Briowireless Inc.
B00000-BFFFFF     (base 16)		Briowireless Inc.
				4593 Louis-B Mayer
				Laval  QC - Quebec  H7P 6G5
				CA

7C-BA-CC   (hex)		Virgin Orbit
700000-7FFFFF     (base 16)		Virgin Orbit
				4022 E. Conant Street
				Long Beach  CA  90808
				US

7C-BA-CC   (hex)		SIGMA-ELEKTRO GmbH
D00000-DFFFFF     (base 16)		SIGMA-ELEKTRO GmbH
				Dr.-Julius-Leber-Str. 15
				Neustadt an der Weinstraße  Germany  67433
				DE

F8-8A-3C   (hex)		Protos GmbH
A00000-AFFFFF     (base 16)		Protos GmbH
				Herrschaftswiesen 11
				Koblach    6842
				AT

4C-65-A8   (hex)		TEL-Electronics Ltd
500000-5FFFFF     (base 16)		TEL-Electronics Ltd
				Sovetskaya, 85
				Molzino  Moscow region  142411
				RU

F8-8A-3C   (hex)		Cadmus Electronic Co.,Ltd.
800000-8FFFFF     (base 16)		Cadmus Electronic Co.,Ltd.
				4F.-3, No.872, Jhongjheng Rd., Jhonghe Dist., 
				New Taipei City  Taiwan (R.O.C.)   23586
				TW

F8-8A-3C   (hex)		Carefree of Colorado
100000-1FFFFF     (base 16)		Carefree of Colorado
				2145 W 6th Ave
				Broomfield  CO  80020
				US

F8-8A-3C   (hex)		KOKKIA INC
500000-5FFFFF     (base 16)		KOKKIA INC
				43575 Mission Blvd, #302
				Fremont  CA  94539
				US

F8-8A-3C   (hex)		Beijing Zhong Chuang Communication Technology Ltd.
600000-6FFFFF     (base 16)		Beijing Zhong Chuang Communication Technology Ltd.
				RM# 712-35, 7th Floor,  #2 Xin Xi Road, Shangdi, Haidian District
				Beijing    100085
				CN

F8-8A-3C   (hex)		GO-LINK TECHNOLOGY CO., LTD.
400000-4FFFFF     (base 16)		GO-LINK TECHNOLOGY CO., LTD.
				Rm. 4, 14F., No.9, Sec.3, Zhonghua Rd.,
				Hsinchu City    30060
				TW

4C-65-A8   (hex)		Plus One Japan Limited
400000-4FFFFF     (base 16)		Plus One Japan Limited
				2-8-6,Nishishinbashi
				Minato-ku  Tokyo  105-0003
				JP

8C-14-7D   (hex)		Electrical & Automation Larsen & Toubro Limited
E00000-EFFFFF     (base 16)		Electrical & Automation Larsen & Toubro Limited
				Mysore Campus, KIADB Industrial Area, Hebbal, Hootagalli
				Mysore  Karnataka  570020
				IN

8C-14-7D   (hex)		Bausch Datacom NV/SA
B00000-BFFFFF     (base 16)		Bausch Datacom NV/SA
				Tiensesteenweg 54-56
				Korbeek-Lo  Vlaams-Brabant - Belgium  3360
				BE

8C-14-7D   (hex)		Nio
000000-0FFFFF     (base 16)		Nio
				3200 North 1st Street
				San Jose  NY  95134
				US

A0-C5-F2   (hex)		AiCare Corp.
400000-4FFFFF     (base 16)		AiCare Corp.
				1917 Scepter Ct
				San Jose  CA  95132
				US

8C-14-7D   (hex)		Shenzhen  Lanxus  technology Co. Ltd.
D00000-DFFFFF     (base 16)		Shenzhen  Lanxus  technology Co. Ltd.
				3rd Floor, Block A, Aerospace micromotor building, Science Park North, Nanshan District
				Shenzhen  China  518000
				CN

F0-23-B9   (hex)		Ubiant
100000-1FFFFF     (base 16)		Ubiant
				2 Place de Francfort
				Lyon    69003
				FR

F0-23-B9   (hex)		Q Core Medical Ltd
B00000-BFFFFF     (base 16)		Q Core Medical Ltd
				Yad Haruzim 29, PO Box 8639
				Netanya    4250529
				IL

40-ED-98   (hex)		Integrated Design Ltd
A00000-AFFFFF     (base 16)		Integrated Design Ltd
				Feltham Point, Air Park Way
				Feltham  Middlesex  TW137EQ
				GB

04-71-4B   (hex)		Shenzhen BoClouds Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Shenzhen BoClouds Technology Co.,Ltd.
				Room 909, Unit A, Cadre Group Centre Building, No.168 TongSha Road, XiLi Town, Nanshan
				Shenzhen  GuangDong  518000
				CN

F0-23-B9   (hex)		Annapurna labs
A00000-AFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

F0-23-B9   (hex)		BSP RUS Ltd.
300000-3FFFFF     (base 16)		BSP RUS Ltd.
				174/1 Stavropolskaya street
				Krasnodar  Krasnodar  350001
				RU

04-71-4B   (hex)		Griesser Electronic AG
300000-3FFFFF     (base 16)		Griesser Electronic AG
				Tänikonerstrasse 3
				Aadorf  Thurgau  8355
				CH

04-71-4B   (hex)		Bureau Electronique Appliquee
500000-5FFFFF     (base 16)		Bureau Electronique Appliquee
				Allee des Noisetiers, 5
				ANGLEUR  LIEGE  4031
				BE

60-D7-E3   (hex)		Ameli s.r.l.
600000-6FFFFF     (base 16)		Ameli s.r.l.
				via Guido Rossa,10
				Impruneta  Firenze  50023
				IT

08-ED-02   (hex)		Telstra Corporation Limited
E00000-EFFFFF     (base 16)		Telstra Corporation Limited
				Level 2 / 150 Lonsdale St
				Melbourne  Victoria  3000
				AU

98-AA-FC   (hex)		Dalian Eastern Display Co., Ltd.
000000-0FFFFF     (base 16)		Dalian Eastern Display Co., Ltd.
				No.99-5 Huaihe Middle Road E.& T Development Zone Dalian, China
				Dalian  Liaoning  116600
				CN

14-4F-D7   (hex)		Edan Instruments, Inc.
E00000-EFFFFF     (base 16)		Edan Instruments, Inc.
				No.15, Jinhui Rd., Jinsha Community, Kengzi Subdistrict, Pingshan District,
				Shenzhen  Guangdong  518122
				CN

98-AA-FC   (hex)		SURTEC
100000-1FFFFF     (base 16)		SURTEC
				616 avenue de l'Europe
				Le Creusot  burgundy  71206
				FR

08-ED-02   (hex)		Origami Energy Ltd
D00000-DFFFFF     (base 16)		Origami Energy Ltd
				Ashcombe Court, Woolsack Way
				Godalming    GU7 1LQ
				GB

14-4F-D7   (hex)		Shanghai B&A Technology Co., Ltd
D00000-DFFFFF     (base 16)		Shanghai B&A Technology Co., Ltd
				4F, No. 150 Cailun Rd, Zhangjiang
				Shanghai    201210
				CN

14-4F-D7   (hex)		Emerson Network Power (India) Pvt. Ltd.
900000-9FFFFF     (base 16)		Emerson Network Power (India) Pvt. Ltd.
				Plot No. G-1, Additional Ambernath Industrial Area,   MIDC Phase-2, Bohonoli 
				Ambernath,  Maharashtra  421 506
				IN

A4-11-63   (hex)		SHENZHEN YIWANJIA INFORMATION TECHNOLOGY CO.,LTD
700000-7FFFFF     (base 16)		SHENZHEN YIWANJIA INFORMATION TECHNOLOGY CO.,LTD
				Zone B,Floor 15,NO.2 Building,Yihe Road,Shilong Community,Shiyan Street,Baoan District
				Shenzhen    518000
				CN

14-4F-D7   (hex)		FLS FINLAND OY
500000-5FFFFF     (base 16)		FLS FINLAND OY
				Voudinkatu 35 A
				Raisio    FI21200
				FI

A4-11-63   (hex)		Carbon, Inc.
500000-5FFFFF     (base 16)		Carbon, Inc.
				312 Chestnut St
				Redwood City  CA  94063
				US

A4-11-63   (hex)		SHENZHEN ZHISHI TECHNOLOGY CO., LTD.
D00000-DFFFFF     (base 16)		SHENZHEN ZHISHI TECHNOLOGY CO., LTD.
				Room 712 in 3A of Hecheng Century Garden，Wuhe Street South No.118，Longgang District，Shenzhen
				SHENZHEN  GUANG DONG  518000
				CN

1C-A0-D3   (hex)		OOO Tekhnotronika
000000-0FFFFF     (base 16)		OOO Tekhnotronika
				Studeniy 4/1
				Moscow    127282
				RU

40-A3-6B   (hex)		Securiton AG
600000-6FFFFF     (base 16)		Securiton AG
				Alpenstrasse 20, P.O. Box 127
				Zollikofen    CH-3052 
				CH

A4-11-63   (hex)		Moog Music Inc.
B00000-BFFFFF     (base 16)		Moog Music Inc.
				160 Broadway St
				Asheville  NC  28801
				US

40-F3-85   (hex)		Teleepoch Ltd
800000-8FFFFF     (base 16)		Teleepoch Ltd
				No.13 Langshan Rd,HiTech Park,Nanshan District
				Shenzhen  Guangdong  518000
				CN

40-F3-85   (hex)		SubPac
000000-0FFFFF     (base 16)		SubPac
				380 Portage Ave.
				Palo Alto  CA  94306
				US

8C-C8-F4   (hex)		Strongbyte Solutions Limited
800000-8FFFFF     (base 16)		Strongbyte Solutions Limited
				Unit 7, Wychwood Business Centre
				Chipping Norton  Oxfordshire  OX7 6XU
				GB

40-F3-85   (hex)		Beijing Zongheng Electro-Mechanical Technology Development Co.
200000-2FFFFF     (base 16)		Beijing Zongheng Electro-Mechanical Technology Development Co.
				No.1 Fenghui East Road, Yongfeng Industry Base, Haidian District, Beijing China
				Beijing    100094
				CN

8C-C8-F4   (hex)		Evaporcool Solutions
E00000-EFFFFF     (base 16)		Evaporcool Solutions
				5100 Wilfong Road
				Memphis  TN  38134
				US

40-F3-85   (hex)		Creanord
A00000-AFFFFF     (base 16)		Creanord
				Pasilanraitio 9B
				Helsinki  Uusimaa  00240
				FI

40-F3-85   (hex)		Digital Bros S.p.A.
D00000-DFFFFF     (base 16)		Digital Bros S.p.A.
				via Tortona, 37
				Milan  MI  20144
				IT

8C-C8-F4   (hex)		Dark Horse Connect LLC
200000-2FFFFF     (base 16)		Dark Horse Connect LLC
				13492 Research Blvd, Ste 336
				Austin  TX  78750
				US

8C-C8-F4   (hex)		Shenzhen KSTAR Science and Technology Co., Ltd
C00000-CFFFFF     (base 16)		Shenzhen KSTAR Science and Technology Co., Ltd
				Kstar Industrial Park, 7th Road, Guangming Hi- Tech Industrial Zone
				Shenzhen    518070
				CN

50-A4-D0   (hex)		Changsha SinoCare, Inc
A00000-AFFFFF     (base 16)		Changsha SinoCare, Inc
				No.265 Gu yuan road  Hi-Tech Zone, Yuelu district 
				Changsha  Hunan  410205
				CN

50-A4-D0   (hex)		Axel Technology
D00000-DFFFFF     (base 16)		Axel Technology
				Via Caduti di Sabbiuno 6/F
				Anzola dell'Emilia    40011
				IT

50-A4-D0   (hex)		Sagetech Corporation
E00000-EFFFFF     (base 16)		Sagetech Corporation
				PO Box 1146
				White Salmon  WA  98672
				US

50-A4-D0   (hex)		Raven Industries Inc.
400000-4FFFFF     (base 16)		Raven Industries Inc.
				205 E 6TH Street
				Sioux Falls  SD  57104
				US

34-04-9E   (hex)		GoChip Inc.
000000-0FFFFF     (base 16)		GoChip Inc.
				275 Airpark Blvd, Suite 100
				Chico  CA  95973
				US

40-ED-98   (hex)		A-IOX INC.
200000-2FFFFF     (base 16)		A-IOX INC.
				10Fl., No. 497, Sec. 2, Tiding Blvd., Neihu Dist.
				Taipei City    11493
				TW

34-04-9E   (hex)		Life Interface Co., Ltd.
600000-6FFFFF     (base 16)		Life Interface Co., Ltd.
				2-1-16
				Minato  Tokyo  1050013
				JP

40-ED-98   (hex)		GuangZhou FiiO Electronics Technology Co.,Ltd
100000-1FFFFF     (base 16)		GuangZhou FiiO Electronics Technology Co.,Ltd
				201,2/F, F Building, Hougang Industrial Zone, Shigang Village, huangshi West Road,Baiyun District
				GuangZhou    510430
				CN

40-ED-98   (hex)		BloomSky,Inc.
C00000-CFFFFF     (base 16)		BloomSky,Inc.
				723 N Shoreline Blvd.
				Mountain view  CA  94043
				US

50-0B-91   (hex)		Igor, Inc.
000000-0FFFFF     (base 16)		Igor, Inc.
				5619 NW 86th St.
				Johnston  IA  50131
				US

A4-58-0F   (hex)		Stone Lock Global, Inc.
100000-1FFFFF     (base 16)		Stone Lock Global, Inc.
				101 N Church St
				Olathe  KS  66061
				US

A4-58-0F   (hex)		AIR LIQUIDE MEDICAL SYSTEMS
800000-8FFFFF     (base 16)		AIR LIQUIDE MEDICAL SYSTEMS
				
				    
				

50-0B-91   (hex)		Annapurna labs
200000-2FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

A4-58-0F   (hex)		Ksenia Security srl
900000-9FFFFF     (base 16)		Ksenia Security srl
				SP Valtesino 44
				Ripatransone  AP  63065
				IT

50-0B-91   (hex)		Sinope technologies Inc
400000-4FFFFF     (base 16)		Sinope technologies Inc
				705 Montrichard
				St-Jean-Sur-Richelieu  Quebec  J2X5K8
				CA

7C-CB-E2   (hex)		1000eyes GmbH
200000-2FFFFF     (base 16)		1000eyes GmbH
				Joachimsthaler Str. 12
				Berlin    10719
				DE

7C-CB-E2   (hex)		SY Electronics Limited
600000-6FFFFF     (base 16)		SY Electronics Limited
				7 Worrall Street
				Salford    M5 4TH
				GB

24-4E-7B   (hex)		Nanjing Wanlida Technology Co., Ltd.
700000-7FFFFF     (base 16)		Nanjing Wanlida Technology Co., Ltd.
				Wanlida Industry Zone, Nanjing County
				Zhangzhou  Fujian  363601
				CN

7C-CB-E2   (hex)		Hangzhou Haohaokaiche Technology Co.,Ltd.
900000-9FFFFF     (base 16)		Hangzhou Haohaokaiche Technology Co.,Ltd.
				Building 7, Haichuang Park, No.998 Wenyi West Road, Yuhang District
				Hangzhou  Zhejiang  331000
				CN

7C-CB-E2   (hex)		DTECH Labs, Inc.
500000-5FFFFF     (base 16)		DTECH Labs, Inc.
				21580 Beaumeade Circle, Suite 230
				Ashburn  VA  20147
				US

48-65-EE   (hex)		shenzhen sunflower technologies CO., LIMITED
600000-6FFFFF     (base 16)		shenzhen sunflower technologies CO., LIMITED
				207, 4th Tower , ZhongXing industrial City, Nanshan zone
				ShenZhen  GangDong  518000
				CN

48-65-EE   (hex)		DefPower Ltd
000000-0FFFFF     (base 16)		DefPower Ltd
				6 Repton Close
				Basildon    SS13 1LE
				GB

4C-E1-73   (hex)		Shenzhen Evolution Dynamics Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen Evolution Dynamics Co., Ltd.
				Room 1212, Wanjun trade building, Baoxing Rd No.21, Baoan District, Shenzhen City, China
				shenzhen  GuangDong  518100
				CN

1C-C0-E1   (hex)		Exigent Sensors
B00000-BFFFFF     (base 16)		Exigent Sensors
				11331 Markon Dr
				Garden Grove  CA  92841
				US

1C-C0-E1   (hex)		Ospicon Company Limited
900000-9FFFFF     (base 16)		Ospicon Company Limited
				Room 1025, 10/F., Metro Centre II, 21 Lam Hing St., 
				Kowloon Bay  Kowloon  00000
				HK

4C-E1-73   (hex)		Nexoforge Inc.
100000-1FFFFF     (base 16)		Nexoforge Inc.
				4514 47 Ave 
				Leduc  Alberta  T9E 5S9
				CA

1C-C0-E1   (hex)		NewLand (NZ) Communication Tech Limited
D00000-DFFFFF     (base 16)		NewLand (NZ) Communication Tech Limited
				39A WAIPA ST BIRKENHEAD
				AUCKLAND  Auckland  0626
				NZ

AC-64-DD   (hex)		PFDC ELANCYL
800000-8FFFFF     (base 16)		PFDC ELANCYL
				LES CAUQUILLOUS 
				81506 LAVAUR CEDEX    81506
				FR

AC-64-DD   (hex)		Shenzhen PuHua Technology Co., Ltd
200000-2FFFFF     (base 16)		Shenzhen PuHua Technology Co., Ltd
				4/F BLDG-B, Forzen Technology Park,Fuyuan 2nd Road, Fuyong Town, Baoan District
				shenzhen    518103
				CN

AC-64-DD   (hex)		Bluewave Global Manufacturing Limited
A00000-AFFFFF     (base 16)		Bluewave Global Manufacturing Limited
				82/F, International Commerce Centre, 1 Austin Road
				West Kowloon    0
				HK

AC-64-DD   (hex)		Wittmann Kunststoffgeräte GmbH
700000-7FFFFF     (base 16)		Wittmann Kunststoffgeräte GmbH
				Lichtblaustraße 10
				Vienna  Vienna  1220
				AT

38-3A-21   (hex)		R3C Information(Shenzhen) Co.，Ltd.
000000-0FFFFF     (base 16)		R3C Information(Shenzhen) Co.，Ltd.
				2F,JinHuiQiou Building,Langshan2 Road,Hi-Tech Ind.Park, Nanshan District
				Shenzhen  GuangDong  86
				CN

38-3A-21   (hex)		HOBART GmbH
100000-1FFFFF     (base 16)		HOBART GmbH
				Robert-Bosch-Straße 17
				Offenburg  Baden-Württemberg  77656
				DE

F8-1D-78   (hex)		GUANGDONG ENOK COMMUNICATION CO., LTD.
E00000-EFFFFF     (base 16)		GUANGDONG ENOK COMMUNICATION CO., LTD.
				No.139 Lixiang road, Songmushan Dalang town, Dongguan,Guangdong ,China
				DongGuan  GuanDong  523795
				CN

38-3A-21   (hex)		OOO NPP Uraltechnologiya
500000-5FFFFF     (base 16)		OOO NPP Uraltechnologiya
				Studencheskaya str. 16-130
				Ekaterinburg    620137
				RU

F8-1D-78   (hex)		WUHAN GUIDE INFRARED CO.,LTD
700000-7FFFFF     (base 16)		WUHAN GUIDE INFRARED CO.,LTD
				No.6 Huanglongshan South Rd
				Wuhan  Hubei  430070
				CN

F8-1D-78   (hex)		SigmaConnectivityAB
B00000-BFFFFF     (base 16)		SigmaConnectivityAB
				Mobilv 10
				Lund    223 62
				SE

C0-D3-91   (hex)		B9Creations
100000-1FFFFF     (base 16)		B9Creations
				525 University Loop Ste 115
				Rapid City  SD  57701
				US

F0-AC-D7   (hex)		Fiziico Co., Ltd.
E00000-EFFFFF     (base 16)		Fiziico Co., Ltd.
				8F-3, No. 15, Ln 360, Sec. 1, Neihu Rd., Neihu District
				Taipei    11493
				TW

98-6D-35   (hex)		my-PV GmbH
C00000-CFFFFF     (base 16)		my-PV GmbH
				Teichstrasse 43
				Neuzeug    4523
				AT

F0-AC-D7   (hex)		Zhejiang Makepower Electronics,Inc.
B00000-BFFFFF     (base 16)		Zhejiang Makepower Electronics,Inc.
				Building 2, Estate 10, Wenzhou Hi-Tech Industrial Development Area, zhejiang, China
				shenzhen    518000
				CN

28-36-38   (hex)		CHARGELIB
500000-5FFFFF     (base 16)		CHARGELIB
				11 CITE VANEAU
				PARIS    75007
				FR

28-36-38   (hex)		Georg Neumann GmbH
600000-6FFFFF     (base 16)		Georg Neumann GmbH
				Leipziger Str. 112
				Berlin    10117
				DE

B0-C5-CA   (hex)		EM-Tech
000000-0FFFFF     (base 16)		EM-Tech
				40, Changwon-daero 1144beon-gil, Seongsan-gu
				Changwon  Gyeongsangnam-do  642-120
				KR

8C-19-2D   (hex)		Pyras Technology Inc.
D00000-DFFFFF     (base 16)		Pyras Technology Inc.
				6F, No. 1353, Chung Cheng Rd., Taoyuan Dist.,
				Taoyuan City  Select State  33071
				TW

8C-19-2D   (hex)		Noritsu Precision Co., Ltd.
000000-0FFFFF     (base 16)		Noritsu Precision Co., Ltd.
				579-1 Umehara
				Wakayama  Wakayama  640-8550
				JP

78-CA-83   (hex)		Eksagate Elektronik Mühendislik ve Bilgisayar San. Tic. A.Ş.
A00000-AFFFFF     (base 16)		Eksagate Elektronik Mühendislik ve Bilgisayar San. Tic. A.Ş.
				ŞEHİT AHMET SOK. 12/1 MECİDİYEKÖY
				istanbul    34381
				TR

8C-19-2D   (hex)		smartHome Partner GmbH
600000-6FFFFF     (base 16)		smartHome Partner GmbH
				Dalbker Strasse 138
				Oerlinghausen  NRW  33813
				DE

1C-87-76   (hex)		Dspread Technology (Beijing) Inc.
000000-0FFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

D0-D9-4F   (hex)		ARROWAVE TECHNOLOGIES LIMITED
C00000-CFFFFF     (base 16)		ARROWAVE TECHNOLOGIES LIMITED
				L1, 1st Floor, LIC Colony, Sector-14, 10th Main, Jeevanbhima Nagar
				Bangalore  Karnataka  560075
				IN

D0-D9-4F   (hex)		Shenzhen FDC Electuonic Co.,Ltd.
A00000-AFFFFF     (base 16)		Shenzhen FDC Electuonic Co.,Ltd.
				Gushu Community, Xixiang Street, Baoan Dist. ShenZhen, GuangDong, China
				Shenzhen  Guangdong  518126
				CN

CC-D3-1E   (hex)		PJG Systementwicklung GmbH
400000-4FFFFF     (base 16)		PJG Systementwicklung GmbH
				Billrothstrasse 2A
				Vienna  Vienna  1190
				AT

CC-D3-1E   (hex)		NantEnergy
C00000-CFFFFF     (base 16)		NantEnergy
				8455 North 90th Street Suite 4
				Scottsdale  AZ  85258
				US

E0-B6-F5   (hex)		Advatek Lighting Pty Ltd
E00000-EFFFFF     (base 16)		Advatek Lighting Pty Ltd
				16 / 62 Ramset Drive
				Chirnside Park  VIC  3116
				AU

E0-B6-F5   (hex)		 Shanghai- British Information Technology Co., Ltd
200000-2FFFFF     (base 16)		 Shanghai- British Information Technology Co., Ltd
				No.1 Building, No.433 Guoshoujing Road, Pudong District, Shanghai
				shanghai    201203
				CN

2C-26-5F   (hex)		AATON DIGITAL
C00000-CFFFFF     (base 16)		AATON DIGITAL
				2 RUE DE LA PAIX
				GRENOBLE  RHONE-ALPES  38000
				FR

50-FF-99   (hex)		Yongjing Shanghai Electronic Science and Technology 
300000-3FFFFF     (base 16)		Yongjing Shanghai Electronic Science and Technology 
				Room 202,Building 2,No.65,Lane1398,Xin Zhu Road,  Minhang District Shanghai.
				shanghai  shanghai  201100 
				CN

E0-B6-F5   (hex)		Motiveprime Consumer Electronics Pvt Ltd
900000-9FFFFF     (base 16)		Motiveprime Consumer Electronics Pvt Ltd
				#244,17th cross Sector 6 HSR Layout
				Bangalore  Karnataka  560102
				IN

E0-B6-F5   (hex)		Shenzhen Civicom Technology Co.,Limited
500000-5FFFFF     (base 16)		Shenzhen Civicom Technology Co.,Limited
				Room 1302,Microprofit Building,Gaoxin 6th Avenue,Hi-tech Park,Nanshan District 
				Shenzhen  Guangdong  518057
				CN

50-FF-99   (hex)		Garrison Technology
500000-5FFFFF     (base 16)		Garrison Technology
				20-22 Wenlock Road
				London  London  N1 7GU
				GB

98-6D-35   (hex)		PDAHL 
500000-5FFFFF     (base 16)		PDAHL 
				Gammagatan  1
				Moelndal  Sweden  43949
				SE

7C-47-7C   (hex)		I-Convergence.com
E00000-EFFFFF     (base 16)		I-Convergence.com
				2A2212, No.32 Baiziwan Road, Chaoyang District
				Beijing    100021
				CN

7C-47-7C   (hex)		RLC Electronics Systems
400000-4FFFFF     (base 16)		RLC Electronics Systems
				10 Corporate Blvd.
				Sinking Spring  PA  19608
				US

7C-47-7C   (hex)		DaLian Cheering Tech Co.,Ltd
900000-9FFFFF     (base 16)		DaLian Cheering Tech Co.,Ltd
				321-1 Tuqiang Street RM308,DDA
				DaLian  Liaoning  116023
				CN

38-FD-FE   (hex)		Swedish Adrenaline AB
B00000-BFFFFF     (base 16)		Swedish Adrenaline AB
				Pilefeltsgatan 73
				Halmstad    302 50
				SE

38-FD-FE   (hex)		Indra Navia AS
800000-8FFFFF     (base 16)		Indra Navia AS
				Olaf Helsets vei 6, P.O. Box 150 Oppsal
				Oslo    0619
				NO

38-FD-FE   (hex)		OOO Group of Industrial Technologies
900000-9FFFFF     (base 16)		OOO Group of Industrial Technologies
				Profsoyuznaya st. 124A
				Moscow  Moscow  117321
				RU

38-FD-FE   (hex)		Edge I&D Co., Ltd.
000000-0FFFFF     (base 16)		Edge I&D Co., Ltd.
				1342-12, Gyeongchung-daero, Chowol-eup
				Gwangju-si  Gyeonggi-do  12735
				KR

5C-F2-86   (hex)		Access IS
700000-7FFFFF     (base 16)		Access IS
				18 Suttons Business Park
				READING  Berks  RG6 1AZ
				GB

38-B8-EB   (hex)		Ajax Systems Inc
C00000-CFFFFF     (base 16)		Ajax Systems Inc
				910 Foulk Road, Suite 201
				Wilmington,    19803
				UA

38-B8-EB   (hex)		NHS Sistemas de Energia
900000-9FFFFF     (base 16)		NHS Sistemas de Energia
				Juscelino Kubitscheck de Oliveira 5270
				Curitiba  Parana  81260000
				BR

38-B8-EB   (hex)		UMLOGICS
400000-4FFFFF     (base 16)		UMLOGICS
				17, Techno2ro, Yuseong-gu
				Daejeon    34012
				KR

38-B8-EB   (hex)		SECAD SA
A00000-AFFFFF     (base 16)		SECAD SA
				Zac des Pellants
				St Martin du Fresne    01430
				FR

38-FD-FE   (hex)		Management Service Corporation
A00000-AFFFFF     (base 16)		Management Service Corporation
				1-7-12 Marunouchi, Chiyoda-ku
				Tokyo    100-0005
				JP

38-B8-EB   (hex)		Bumjin C&L Co., Ltd.
000000-0FFFFF     (base 16)		Bumjin C&L Co., Ltd.
				9B 10L, 833-14 Wonsi-dong Danwon-gu
				Ansan  Gyeonggi  15612
				KR

78-CA-83   (hex)		Pinhole (Beijing) Technology Co., Ltd.
400000-4FFFFF     (base 16)		Pinhole (Beijing) Technology Co., Ltd.
				Room 1001-008, No.1 Building, No. 3 Haidian Street, Haidian District
				Beijing    100190
				CN

78-CA-83   (hex)		Neofon GmbH
300000-3FFFFF     (base 16)		Neofon GmbH
				Sonnengrund 13a
				Starnberg    82319
				DE

78-CA-83   (hex)		APC
200000-2FFFFF     (base 16)		APC
				PO Box 30204
				Al-Khobar    31952
				SA

78-CA-83   (hex)		Nomiku
600000-6FFFFF     (base 16)		Nomiku
				475 Alvarado St Apt 2
				San Francisco  CA  94114
				US

1C-88-79   (hex)		Orion Labs inc
E00000-EFFFFF     (base 16)		Orion Labs inc
				2125 Mission St
				San Francisco  CA  94110
				US

1C-88-79   (hex)		Beijing Raycores Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Beijing Raycores Technology Co.,Ltd
				1113# 11/F #A Building No.118 Huilongguan West Street,Changping District
				Beijing    102208
				CN

1C-87-74   (hex)		Surtec Industries, Inc
800000-8FFFFF     (base 16)		Surtec Industries, Inc
				9 Kon Jan North Road, Liutu Industrial Zone
				Keelung    20647
				TW

1C-88-79   (hex)		Ultraflux
400000-4FFFFF     (base 16)		Ultraflux
				9 Allee Rosa Luxembourg
				Eragny    95610
				FR

1C-87-74   (hex)		Nebbiolo Technologies
A00000-AFFFFF     (base 16)		Nebbiolo Technologies
				860 Hillview Court, #310
				Milpitas  CA  94035
				US

1C-87-74   (hex)		Wide World Trade HK ltd.
900000-9FFFFF     (base 16)		Wide World Trade HK ltd.
				Office Tower, Convention Plaza, 1 Harbour Road, Wanchai
				Hong Kong    4210
				HK

1C-87-74   (hex)		Silora R&D
300000-3FFFFF     (base 16)		Silora R&D
				Kibbutz Kfar-Masaryk
				Haifa    25208
				IL

1C-87-74   (hex)		SIGFOX
100000-1FFFFF     (base 16)		SIGFOX
				Bâtiment E-volution - 425, rue Jean Rostand 
				Labege    31670
				FR

1C-87-76   (hex)		Qivivo
D00000-DFFFFF     (base 16)		Qivivo
				11 impasse Juton
				NANTES    44000
				FR

1C-87-76   (hex)		Guangzhou Video-Star Electronics Co.,Ltd.
800000-8FFFFF     (base 16)		Guangzhou Video-Star Electronics Co.,Ltd.
				6F/No.6 Building, No.9/4th Lanyu St., GZ Economy&Technology Development Area
				Guangzhou  Guangdong  510730
				CN

1C-87-76   (hex)		philandro Software GmbH
600000-6FFFFF     (base 16)		philandro Software GmbH
				Rosenbergstr. 46
				Stuttgart    70176
				DE

1C-87-76   (hex)		Corporate Systems Engineering 
700000-7FFFFF     (base 16)		Corporate Systems Engineering 
				1215 Brookville Way
				Indianapolis   IN  46239
				US

1C-87-76   (hex)		Tokyo Drawing Ltd.
900000-9FFFFF     (base 16)		Tokyo Drawing Ltd.
				103 Ni Terai-machi
				Nomi-shi  Ishikawa  923-1121
				JP

1C-87-76   (hex)		Unjo AB
300000-3FFFFF     (base 16)		Unjo AB
				Bergfotsgatan 3B
				Mölndal    SE-43135
				SE

1C-87-79   (hex)		Visual Land Inc.
300000-3FFFFF     (base 16)		Visual Land Inc.
				17785 Center Court Dr. #670
				Cerritos  CA  90703
				US

1C-87-79   (hex)		Wurm GmbH & Co. KG Elektronische Systeme
000000-0FFFFF     (base 16)		Wurm GmbH & Co. KG Elektronische Systeme
				Morsbachtalstr. 30
				Remscheid    42857
				DE

1C-87-76   (hex)		Ibeo Automotive Systems GmbH
200000-2FFFFF     (base 16)		Ibeo Automotive Systems GmbH
				Merkurring 60-62
				Hamburg    22143
				DE

40-A3-6B   (hex)		FAOD Co.,Ltd.
D00000-DFFFFF     (base 16)		FAOD Co.,Ltd.
				#301, U-Tower, 1029, Yeongdeok-dong, Giheung-gu
				Yongin-si  Gyeonggi-do  446-908
				KR

84-39-BE   (hex)		Guangdong SunMeng Information Technology Co. Ltd.
900000-9FFFFF     (base 16)		Guangdong SunMeng Information Technology Co. Ltd.
				Yuexiu District of Shuiyin Road No.56th courtyard No.1 building six-floor
				Guangzhou  Guangdong  510627
				CN

84-39-BE   (hex)		Shenzhen IP3 Century Intelligent Technology Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen IP3 Century Intelligent Technology Co., Ltd
				Unit A1, 11F, Block A, Tongfang Information Harbor, No.11, Langshan Road, Hi-Tech Park(North), Nanshan District, Shenzhen
				Shenzhen  Guangdong  518010
				CN

40-A3-6B   (hex)		TOPROOTTechnology Corp. Ltd.
200000-2FFFFF     (base 16)		TOPROOTTechnology Corp. Ltd.
				5F-8, No. 14, Lane 609, Sec.5, Chongsin Rd., 
				Sanchong Dist.   NewTaipei City   241
				TW

70-88-6B   (hex)		Beijing Strongleader Science & Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Beijing Strongleader Science & Technology Co., Ltd.
				No. 12 Yard, Zhong Guan Cun South St. 
				Beijing  Beijing  100081
				CN

70-88-6B   (hex)		RHXTune Technology Co.,Ltd
A00000-AFFFFF     (base 16)		RHXTune Technology Co.,Ltd
				Room 409, TianGong building A, Xueyuan Road 30, Haidian District
				Beijing  Beijing  100083
				CN

70-88-6B   (hex)		HORI CO., LTD.
400000-4FFFFF     (base 16)		HORI CO., LTD.
				640, Saedo-cho
				Yokohama-city  Kanagawa  224-0054
				JP

70-88-6B   (hex)		MAX4G, Inc.
C00000-CFFFFF     (base 16)		MAX4G, Inc.
				6400 Flying Cloud Drive, Suite 225
				Eden Prairie  MN  55344
				US

70-88-6B   (hex)		Veracity UK Ltd
000000-0FFFFF     (base 16)		Veracity UK Ltd
				4 Dow Road
				Monkton, Prestwick    KA9 2TU
				GB

80-0A-80   (hex)		Dongguan I-Chime electrinics Co.,Ltd
100000-1FFFFF     (base 16)		Dongguan I-Chime electrinics Co.,Ltd
				3/F,A/B,west of Xiangmang road,Fugang village
				Dongguan  Guangdong  523660
				CN

CC-1B-E0   (hex)		Sichuan Dianjia network technology Co.Ltd.
700000-7FFFFF     (base 16)		Sichuan Dianjia network technology Co.Ltd.
				East 6F,No.51 East Wenshui Road,Hongkou District
				Shanghai  Shanghai  200437
				CN

CC-1B-E0   (hex)		i-Trinetech Co.,Ltd.
200000-2FFFFF     (base 16)		i-Trinetech Co.,Ltd.
				4th FL.,East Wing of M-8 Building,Sparrow Ridge Industrial Zone,Science&Technology Park,Nanshan District.,Shenzhen City
				Shenzhen  Guangdong  518057
				CN

CC-1B-E0   (hex)		ART&CORE Inc
B00000-BFFFFF     (base 16)		ART&CORE Inc
				6F, 44, Burim-ro 170beon-gil, Dongan-gu,
				Anyang-si  Gyeonggi-do  431-060
				KR

00-55-DA   (hex)		Shinko Technos co.,ltd.
000000-0FFFFF     (base 16)		Shinko Technos co.,ltd.
				2-5-1, Senba Higashi
				Mino  Osaka  562-0035
				JP

C8-8E-D1   (hex)		Aventics GmbH
E00000-EFFFFF     (base 16)		Aventics GmbH
				Ulmer Str. 4
				Laatzen  Lower Saxony  30880
				DE

A0-3E-6B   (hex)		iLoda Solutions Limited
300000-3FFFFF     (base 16)		iLoda Solutions Limited
				217A, 2/F, Enterprise Place
				Hong Kong  Hong Kong  000000
				HK

A0-3E-6B   (hex)		Wuhan Rui Ying Tong Network Technology Co., Ltd(China)
600000-6FFFFF     (base 16)		Wuhan Rui Ying Tong Network Technology Co., Ltd(China)
				No.303, Optics Valley Avenue, Wuhan, Hubei, China
				Wuhan  Hubei  430074
				CN

A0-3E-6B   (hex)		SinoGrid Software Systems Inc.
700000-7FFFFF     (base 16)		SinoGrid Software Systems Inc.
				3rd Floor , No.4 Aviation Industry Technology Park
				Beijing  Beijing  101111
				CN

1C-21-D1   (hex)		Microview Science and Technology Co.,Ltd
300000-3FFFFF     (base 16)		Microview Science and Technology Co.,Ltd
				NO.29 Zhufang Road,Shangdi,Haidian District,Beijing,P.R.China
				Beijing  Beijing  100085
				CN

1C-21-D1   (hex)		Scientific-Production Enterprise Dynamics
400000-4FFFFF     (base 16)		Scientific-Production Enterprise Dynamics
				Anisimova street, 6
				Cheboksary  Chuvash Republic  428015
				RU

DC-44-27   (hex)		Neusoft Corporation
900000-9FFFFF     (base 16)		Neusoft Corporation
				No.2 Xinxiu Street,Hunnan New District,Shenyang,Liaoning,China
				Shenyang  Liaoning  110179
				CN

C8-8E-D1   (hex)		AISWORLD PRIVATE LIMITED
000000-0FFFFF     (base 16)		AISWORLD PRIVATE LIMITED
				ROOM 1406, 14/F., WING TUCK COMMERCIAL CENTRE 177-183 WING LOK STREET, SHEUNG WAN. HONG KONG
				HONG KONG  SHEUNG WAN  999077
				HK

B0-C5-CA   (hex)		Audio Elektronik İthalat İhracat San ve Tic A.Ş.
E00000-EFFFFF     (base 16)		Audio Elektronik İthalat İhracat San ve Tic A.Ş.
				Esenkent Mah. Barajyolu cad. No:26
				İstanbul  Ümraniye  34776
				TR

B0-C5-CA   (hex)		Private
D00000-DFFFFF     (base 16)		Private

B0-C5-CA   (hex)		XMetrics
C00000-CFFFFF     (base 16)		XMetrics
				Via Caravaggio, 3
				Bussero  MI  20060
				IT

DC-44-27   (hex)		Century Audio, Inc.
500000-5FFFFF     (base 16)		Century Audio, Inc.
				6220 Overlook Rd.
				Peachtree Corners  Georgia  30092
				US

B0-C5-CA   (hex)		abode systems, inc.
300000-3FFFFF     (base 16)		abode systems, inc.
				2625 Middlefield Road
				Palo Alto  CA  94306
				US

78-C2-C0   (hex)		Huwomobility
E00000-EFFFFF     (base 16)		Huwomobility
				1196 Borregas Ave, Suite 100
				Sunnyvale  California  94089
				US

78-C2-C0   (hex)		SES
900000-9FFFFF     (base 16)		SES
				35-39 avenue du Danemark
				TOURS  Indre et Loire  37072
				FR

74-F8-DB   (hex)		Simon Electric (China) Co.,ltd
D00000-DFFFFF     (base 16)		Simon Electric (China) Co.,ltd
				No.1 Simon Rd, Jiangsu Haian, China
				Nantong  Jiangsu  226601
				CN

74-F8-DB   (hex)		Songam Syscom Co. LTD.
800000-8FFFFF     (base 16)		Songam Syscom Co. LTD.
				1672-1, Donghwa-Ri, Munmak-Eup
				Wonju  Gangwon-Do  220-801
				KR

74-F8-DB   (hex)		Shenzhen Melon Electronics Co.,Ltd
600000-6FFFFF     (base 16)		Shenzhen Melon Electronics Co.,Ltd
				3 Floor ,A5 building ,YinLong Technology Industrial Park ,Shenshan Road 292 ,Longgang District
				Shenzhen  Guangdong  518116
				CN

78-C2-C0   (hex)		XRONOS-INC
100000-1FFFFF     (base 16)		XRONOS-INC
				SHINANOMACHI35
				SHINJUKUKU  TOKYO  160-0016
				JP

B4-37-D1   (hex)		Union Tecnologica Noxium S.L.
E00000-EFFFFF     (base 16)		Union Tecnologica Noxium S.L.
				Calle Averroes nº8, Edificio Acropolis
				Sevilla  Sevilla  41020
				ES

B4-37-D1   (hex)		ZXY Sport Tracking
D00000-DFFFFF     (base 16)		ZXY Sport Tracking
				Ingvald Ystgaards vei 1
				Trondheim  Norway  7047
				NO

B4-37-D1   (hex)		NSI Co., Ltd.
B00000-BFFFFF     (base 16)		NSI Co., Ltd.
				3F, No.33-1, Lane235, Sung-Chiang Road
				Taipei    10483
				TW

88-5D-90   (hex)		CPAC Systems
300000-3FFFFF     (base 16)		CPAC Systems
				Bergskroken 3
				Gothenburg  Västra Götaland  40123
				SE

88-5D-90   (hex)		Shenzhen JingHanDa Electronics Co.Ltd
500000-5FFFFF     (base 16)		Shenzhen JingHanDa Electronics Co.Ltd
				5th Floor,No 4 ,Road 1,ShangXue Technology industrial Park,LongGang district,ShenZhen,GuangDong,China
				ShenZhen  GuangDong  518129
				CN

88-5D-90   (hex)		FOSHAN HUAGUO OPTICAL CO.,LTD
000000-0FFFFF     (base 16)		FOSHAN HUAGUO OPTICAL CO.,LTD
				NO.3 Changhong East Road,Zhanghca Town Foshan City Guang Dong,China
				Foshan  Guang Dong  528000
				CN

80-7B-85   (hex)		Mersen
E00000-EFFFFF     (base 16)		Mersen
				374 Merrimac St
				Newburyport  MA  01950
				US

54-9A-11   (hex)		Orient Direct, Inc.
600000-6FFFFF     (base 16)		Orient Direct, Inc.
				974 Commercial St.
				Palo Alto  California  94303
				US

54-9A-11   (hex)		Xi'an Hua Fan Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Xi'an Hua Fan Technology Co.,Ltd.
				Room No.1,3rd Floor,Xi Tie Gong Cheng Da Sha,No.205 Jinhua Road,Xincheng District
				Xi'an  Shaanxi  710032
				CN

88-5D-90   (hex)		Hexaglobe
D00000-DFFFFF     (base 16)		Hexaglobe
				1 rue Méhul
				  Paris  75002
				FR

80-7B-85   (hex)		Kaynes Technology India Pvt Ltd
D00000-DFFFFF     (base 16)		Kaynes Technology India Pvt Ltd
				23-25, Belagola Food Industrial Area
				MYSORE  Karnataka  570016
				IN

64-FB-81   (hex)		SHANGHAI   SIMCOM   LIMITED
000000-0FFFFF     (base 16)		SHANGHAI   SIMCOM   LIMITED
				Building A, SIM technology Building, N0.633 JinZhong Road,
				Shanghai  /  200335
				CN

64-FB-81   (hex)		XIMO Communication Technology Co., Ltd
600000-6FFFFF     (base 16)		XIMO Communication Technology Co., Ltd
				3rd Floor,F region,418#,Tian Lin Road, Xuhui District, Shanghai
				shanghai  shanghai  200233
				CN

1C-CA-E3   (hex)		Dabi Atlante S/A Industrias Medico Odontológicas
E00000-EFFFFF     (base 16)		Dabi Atlante S/A Industrias Medico Odontológicas
				Av. Presidente Castelo Branco, 2525
				Ribeirão Preto  São Paulo  14095-903
				BR

80-E4-DA   (hex)		Dalian Roiland Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Dalian Roiland Technology Co.,Ltd
				11th floor,7Huixian Yuan,
				Dalian,  Liaoning  116023
				CN

80-E4-DA   (hex)		CAVALRY STORAGE INC
500000-5FFFFF     (base 16)		CAVALRY STORAGE INC
				4251 E BRICKELL ST
				ONTARIO  CA  91761
				US

80-E4-DA   (hex)		BroadMedia Co., Ltd.
600000-6FFFFF     (base 16)		BroadMedia Co., Ltd.
				102-124, 106 Youngdeungpo Ro
				Seoul  N/A  150-935
				KR

1C-CA-E3   (hex)		Shenzhen Smart Device Technology Co.,LTD
300000-3FFFFF     (base 16)		Shenzhen Smart Device Technology Co.,LTD
				SSMEC Building, Gao Xin Nan First Avenue Hi-Tech Park South
				Shenzhen  GuangDong  518057
				CN

1C-CA-E3   (hex)		Sunray Medical Apparatus Co.,Ltd.
400000-4FFFFF     (base 16)		Sunray Medical Apparatus Co.,Ltd.
				 4/F No.242 Tianhe Dong Road ,510620 Guangzhou,  PEOPLE’S REPUBLICA OF CHINA
				Guangzhou  Guangdong  510620
				CN

1C-CA-E3   (hex)		SHIN-YOSHA CORPORATION
900000-9FFFFF     (base 16)		SHIN-YOSHA CORPORATION
				Oyamagaoka3-9-1
				Machida  Tokyo  1940215
				JP

1C-CA-E3   (hex)		OxySec S.r.l.
800000-8FFFFF     (base 16)		OxySec S.r.l.
				via delle Querce, 7
				Treviolo  Bergamo  24048
				IT

2C-6A-6F   (hex)		Milbank Manufacturing Co.
800000-8FFFFF     (base 16)		Milbank Manufacturing Co.
				4801 Deramus Ave.
				Kansas City  MO  64120
				US

2C-D1-41   (hex)		Ezee Systems Limited
100000-1FFFFF     (base 16)		Ezee Systems Limited
				Room 2103, Singga Commercial Centre
				Hong Kong  HKSAR  HK
				HK

2C-6A-6F   (hex)		EATON FHF Funke + Huster Fernsig GmbH
E00000-EFFFFF     (base 16)		EATON FHF Funke + Huster Fernsig GmbH
				Gewerbeallee 15 - 19
				Muelheim an der Ruhr  NRW  45478
				DE

90-C6-82   (hex)		Lachmann & Rink GmbH
B00000-BFFFFF     (base 16)		Lachmann & Rink GmbH
				Hommeswiese 129
				Freudenberg  NRW  57258
				DE

90-C6-82   (hex)		Li Seng Technology Ltd.
C00000-CFFFFF     (base 16)		Li Seng Technology Ltd.
				Room 901, 9/F Shiu Fung Hong Building
				  Hong Kong  852
				HK

90-C6-82   (hex)		S.A.E.T. S.R.L.
500000-5FFFFF     (base 16)		S.A.E.T. S.R.L.
				VIA PO 13
				BUSCA  CUNEO  12022
				IT

2C-D1-41   (hex)		Resus Industries
B00000-BFFFFF     (base 16)		Resus Industries
				Kleine monnikenwerve 9
				Brugge  West-Vlaanderen  8000
				BE

2C-6A-6F   (hex)		SHEN ZHEN SIS SCIENCE & TECHNOLOGY LTD.
500000-5FFFFF     (base 16)		SHEN ZHEN SIS SCIENCE & TECHNOLOGY LTD.
				Room 201, Block A, No.1, Qianwan Road 1,
				Shenzhen  Guangdong  518000
				CN

A0-BB-3E   (hex)		Shenzhen Talent Technology company limited
D00000-DFFFFF     (base 16)		Shenzhen Talent Technology company limited
				105~107,1/F,Bldg T3,Shenzhen SW Park,No 011,High-teh South 7th Road, Nanshan District,Shenzhen
				Shenzhen  Guangdong  518040
				CN

A0-BB-3E   (hex)		Ewig Industries Macao Commercial Offshore Ltd
C00000-CFFFFF     (base 16)		Ewig Industries Macao Commercial Offshore Ltd
				Avenida da Praia Grande No. 619
				Macau  Macau  000000
				CN

2C-6A-6F   (hex)		NanChang LangJie Technology Co.,Ltd
200000-2FFFFF     (base 16)		NanChang LangJie Technology Co.,Ltd
				Room 819,No.3 Building,XianFeng Property,No.948 HuoJu Street,GaoXin District
				NanChang  JiangXi  330096
				CN

A0-BB-3E   (hex)		DirectOut GmbH
200000-2FFFFF     (base 16)		DirectOut GmbH
				Leipziger Str. 32
				Mittweida  Saxony  09648
				DE

98-02-D8   (hex)		EBI  Ltd.
500000-5FFFFF     (base 16)		EBI  Ltd.
				1305 Metro Loft
				Kwai Chung  NT  HKG
				HK

98-02-D8   (hex)		AGV spa
C00000-CFFFFF     (base 16)		AGV spa
				Strada Savonesa 12
				rivalta scrivia (AL)  italy  15057
				IT

98-02-D8   (hex)		United Power Research Technology Corp.
200000-2FFFFF     (base 16)		United Power Research Technology Corp.
				8F.-5,No.83,Sec.2,Dongda Rd.,North Dist.,
				Hsinchu City  Taiwan  300
				TW

28-FD-80   (hex)		Poket Hardware GmbH
B00000-BFFFFF     (base 16)		Poket Hardware GmbH
				Borsigstr. 9.
				Berlin  Berlin  10115
				DE

28-FD-80   (hex)		Apollo Digital (Taiwan) Ltd.
A00000-AFFFFF     (base 16)		Apollo Digital (Taiwan) Ltd.
				Rm. A, 9F, No.68, Sec. 2,
				New Taipei City  Taiwan  22065
				TW

2C-26-5F   (hex)		Rexgen Inc.
B00000-BFFFFF     (base 16)		Rexgen Inc.
				127, Wonmanseong-ro, Deokjin -gu
				Jeonju-si  Jeonbuk  561-202
				KR

28-FD-80   (hex)		Xiaocong Network Limited
500000-5FFFFF     (base 16)		Xiaocong Network Limited
				2F,Building 3, No.200, Guoding East Road (Innovation Works)
				  Shanghai  200093
				CN

28-FD-80   (hex)		JINLITONG INTERNATIONAL CO.,LTD
900000-9FFFFF     (base 16)		JINLITONG INTERNATIONAL CO.,LTD
				KangMai Industrial Zone ,B building, F/3,
				Shenzhen  guangdong  518110
				CN

28-FD-80   (hex)		Jasco Products Company
800000-8FFFFF     (base 16)		Jasco Products Company
				10 East Memorial Road
				Oklahoma City  Oklahoma  73114
				US

28-FD-80   (hex)		Vigil Monitoring
600000-6FFFFF     (base 16)		Vigil Monitoring
				Suite 201, Ironbank
				Auckland  Auckland  1010
				NZ

2C-26-5F   (hex)		Brüel & Kjaer Vibro GmbH
900000-9FFFFF     (base 16)		Brüel & Kjaer Vibro GmbH
				Leydheckerstrasse 10
				Darmstadt  Hessen  64293
				DE

2C-26-5F   (hex)		E Core Corporation
D00000-DFFFFF     (base 16)		E Core Corporation
				2F., No.15, Yijiang St., Zhongshan Dist.,
				Taipie  Taiwan  10456
				TW

0C-EF-AF   (hex)		Syntrans AB
700000-7FFFFF     (base 16)		Syntrans AB
				Teknikringen 4C
				Linkoping    SE-58330
				SE

0C-EF-AF   (hex)		Infinisource Inc.
E00000-EFFFFF     (base 16)		Infinisource Inc.
				9350 South 150 East
				Sandy  UT  84070
				US

0C-EF-AF   (hex)		CJSC «Svyaz Engineering»
D00000-DFFFFF     (base 16)		CJSC «Svyaz Engineering»
				6th Radialnaya, 9
				  Moscow  115404
				

A4-4F-29   (hex)		Shenzhen Huadoo Bright Group Limitied
C00000-CFFFFF     (base 16)		Shenzhen Huadoo Bright Group Limitied
				Room 13E, Jinsong Buiding, Tai ran 4th Rood, Chegong Miao,Futian Distrct
				Shenzhen  Guangdong  51800
				CN

F8-02-78   (hex)		EMBUX Technology Co., Ltd.
800000-8FFFFF     (base 16)		EMBUX Technology Co., Ltd.
				11F, 657, Bannan Road
				New Taipei City  New Taipei City  235
				TW

F8-02-78   (hex)		Witium Co., Ltd
600000-6FFFFF     (base 16)		Witium Co., Ltd
				Room 605A, E Building, NO.7001 Zhongchun Road
				Shanghai  Shanghai  201101
				CN

3C-39-E7   (hex)		Hannstar Display Corp
000000-0FFFFF     (base 16)		Hannstar Display Corp
				4F., No.15, Ln. 168, Xingshan Rd.,
				 Taipei  Taiwan (R.O.C.)  11469
				TW

10-07-23   (hex)		TESSERA TECHNOLOGY INC.
A00000-AFFFFF     (base 16)		TESSERA TECHNOLOGY INC.
				2710-1 4F, Noborito, Tama-ku
				Kawasaki-shi  Kanagawa  214-0014
				JP

A4-4F-29   (hex)		Certi Networks Sdn Bhd
900000-9FFFFF     (base 16)		Certi Networks Sdn Bhd
				2-8 Level 8 Wisma Manjalara
				Kuala Lumpur  Wilayah Persekutuan Kuala Lumpur  52200
				MY

3C-39-E7   (hex)		MARPOSS SPA
E00000-EFFFFF     (base 16)		MARPOSS SPA
				VIA SALICETO 13
				BENTIVOGLIO  BOLOGNA  40010
				IT

A4-4F-29   (hex)		Protean Payment
700000-7FFFFF     (base 16)		Protean Payment
				617 Detroit St
				Ann Arbor  Michigan  48104
				US

A4-4F-29   (hex)		Innovations in Optics, Inc.
800000-8FFFFF     (base 16)		Innovations in Optics, Inc.
				82 Cummings Park
				Woburn  MA  01801
				US

10-07-23   (hex)		Wireless input technology Inc.
900000-9FFFFF     (base 16)		Wireless input technology Inc.
				34339 N. Bobolink Trail
				Grayslake  IL  60030
				US

3C-39-E7   (hex)		RO.VE.R. Laboratories S.p.A
600000-6FFFFF     (base 16)		RO.VE.R. Laboratories S.p.A
				Via Parini 2/4
				Colombare di SIrmione  BS  25019
				IT

10-07-23   (hex)		Tongfang computer co.Ltd.
300000-3FFFFF     (base 16)		Tongfang computer co.Ltd.
				F8 building 2, 2nd section, Gaoxinqi strategic emerging industry part, liuxian 1st Rd. the 67 district, Bao an district, shenzhen, china
				shenzhen  guangdong  518100
				CN

D0-22-12   (hex)		SHENZHEN ZHONGXI SECURITY CO.,LTD
D00000-DFFFFF     (base 16)		SHENZHEN ZHONGXI SECURITY CO.,LTD
				2F,East 420Building,Bagua 3rd, Futian, Shenzhen
				shenzhen  guangdong  ZIP
				CN

E8-18-63   (hex)		Shenzhen Hipad Telecommunication Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen Hipad Telecommunication Technology Co.,Ltd
				Room 502-503,Building C3 ,Kexing Science Park,Sci-Tech.Park(M.Zone),Nanshan District,Shenzhen
				Shenzhen  Guangdong  518000
				CN

10-07-23   (hex)		Audio Engineering Ltd.
400000-4FFFFF     (base 16)		Audio Engineering Ltd.
				75 Parnell Rise
				Auckland    1052
				NZ

E8-18-63   (hex)		WETEK ELECTRONICS LIMITED
500000-5FFFFF     (base 16)		WETEK ELECTRONICS LIMITED
				#604, TOWER A NEW TRADE PLAZA
				HONG KONG  HONG KONG  999077
				HK

E8-18-63   (hex)		DIGITAL DYNAMICS, INC.
D00000-DFFFFF     (base 16)		DIGITAL DYNAMICS, INC.
				5 VICTOR SQUARE
				SCOTTS VALLEY  CA.  95066
				US

74-E1-4A   (hex)		Wuhan Shenghong Laser Projection Technology Co.,LTD
C00000-CFFFFF     (base 16)		Wuhan Shenghong Laser Projection Technology Co.,LTD
				Room 403,Tower A11,Optical valley software Park,No.1 GuanShan first Road,East lake development Zone
				Wuhan  Hubei  430000
				CN

74-E1-4A   (hex)		Diamond Kinetics
E00000-EFFFFF     (base 16)		Diamond Kinetics
				700 River Ave., Suite 318
				Pittsburgh  PA  15212
				US

74-E1-4A   (hex)		KLIMAT SOLEC Sp. z o.o.
200000-2FFFFF     (base 16)		KLIMAT SOLEC Sp. z o.o.
				Nadborna 2a
				Solec Kujawski  Kujawsko-Pomorskie  86-050
				PL

74-E1-4A   (hex)		Altenburger Electronic GmbH
000000-0FFFFF     (base 16)		Altenburger Electronic GmbH
				Schlossweg 5
				Seelbach  BW  77960
				DE

74-E1-4A   (hex)		Cerevo Inc.
100000-1FFFFF     (base 16)		Cerevo Inc.
				River-side-seven bldg. 3F, 2-7-9, Sotokanda
				Tiyoda  Tokyo  101-0021
				JP

74-E1-4A   (hex)		Emerging Technology (Holdings) Ltd.
600000-6FFFFF     (base 16)		Emerging Technology (Holdings) Ltd.
				17/F, C-Bons International Center, 108 Wai Yip Street,
				Hong Kong  Hong Kong  Hong Kong
				CN

B8-D8-12   (hex)		Neuropace Inc.
700000-7FFFFF     (base 16)		Neuropace Inc.
				455 N Bernardo Ave
				Mountain View  California  94043
				US

BC-66-41   (hex)		Shenzhen General Measure Technology Co., Ltd
900000-9FFFFF     (base 16)		Shenzhen General Measure Technology Co., Ltd
				4th Floor, No.6 Block Science&Technologt Industrial Park of Privately Owned Enterprises
				Shenzhen  Guangdong  518000
				CN

BC-66-41   (hex)		Scientific Games
500000-5FFFFF     (base 16)		Scientific Games
				1500 Bluegrass Lakes Parkway
				Alpharetta  GA  30004
				US

E4-95-6E   (hex)		Shanghai Hoping Technology Co., Ltd.
200000-2FFFFF     (base 16)		Shanghai Hoping Technology Co., Ltd.
				Room 224, Building 3, No.99
				  Shanghai  201210
				CN

BC-66-41   (hex)		Solectria Renewables, LLC
300000-3FFFFF     (base 16)		Solectria Renewables, LLC
				360 Merrimack St.
				Lawrence  MA  01843
				US

E4-95-6E   (hex)		SHENZHEN JOYETECH ELECTRONICS CO., LTD.
600000-6FFFFF     (base 16)		SHENZHEN JOYETECH ELECTRONICS CO., LTD.
				9th Blvd.Changxing New Tech.Industry Zone,Shajing Town,Baoan District
				shenzhen  Guangdong  518104
				CN

58-FC-DB   (hex)		Shanghai Qianjin Electronic Equipment Co. Ltd
800000-8FFFFF     (base 16)		Shanghai Qianjin Electronic Equipment Co. Ltd
				 4/F,Building No.2,401 Caobao Road
				  Shanghai  200233
				

58-FC-DB   (hex)		Shenzhen Siecom Communication Technology Development Co.,Ltd.
500000-5FFFFF     (base 16)		Shenzhen Siecom Communication Technology Development Co.,Ltd.
				Wanwei building401 ,Industry 5th Road
				Shenzhen  Guangdong  518067
				CN

58-FC-DB   (hex)		Excenon Mobile Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Excenon Mobile Technology Co., Ltd.
				5th Floor, Building 1, Software Park, Kejizhong 2nd Rd, High-Tech Zone, Nanshan
				Shenzhen  Guangdong  518000
				CN

B0-1F-81   (hex)		Advanced & Wise Technology Corp.
E00000-EFFFFF     (base 16)		Advanced & Wise Technology Corp.
				5F, No. 3-2, Industry East 9th Road, Hsinchu Science Park,
				Hsinchu City  Hsinchu  30075
				TW

58-FC-DB   (hex)		Custom Biogenic Systems
300000-3FFFFF     (base 16)		Custom Biogenic Systems
				74100 Van Dyke Road
				MI  Michigan  48065
				US

B0-1F-81   (hex)		Technion Oy
800000-8FFFFF     (base 16)		Technion Oy
				Linkkikatu 15
				Naantali  Länsi-Suomi  21100
				FI

B0-1F-81   (hex)		COMOTA Co., Ltd.
600000-6FFFFF     (base 16)		COMOTA Co., Ltd.
				Queens Tower C 10F
				Yokohama  Kanagawa  220-6210
				JP

BC-66-41   (hex)		InSync Technology Ltd
000000-0FFFFF     (base 16)		InSync Technology Ltd
				Tilbrook House
				Petersfield  Hampshire  GU31 4AZ
				GB

58-FC-DB   (hex)		Certis Technology International
100000-1FFFFF     (base 16)		Certis Technology International
				Certis CISCO
				  Singapore  409179
				

B0-1F-81   (hex)		Uvax Concepts
100000-1FFFFF     (base 16)		Uvax Concepts
				Calle Corretger 71-2
				Paterna  Other  46980
				ES

B0-1F-81   (hex)		Dalian GigaTec Electronics Co.,Ltd
000000-0FFFFF     (base 16)		Dalian GigaTec Electronics Co.,Ltd
				No.3 Kehai Street, Hi-Tech Zone
				Dalian  Liao Ning  116023
				CN

F4-0E-11   (hex)		DXG Technology Corp.
D00000-DFFFFF     (base 16)		DXG Technology Corp.
				15FL.,NO.4,SEC.3,
				Taipei    10477
				TW

F4-0E-11   (hex)		Dayang Technology Development Inc.
400000-4FFFFF     (base 16)		Dayang Technology Development Inc.
				Dayang Building
				Haidian District  Beijing  100193
				CN

14-1F-BA   (hex)		Black Moth Technologies
900000-9FFFFF     (base 16)		Black Moth Technologies
				17 Waverley St
				Annerley  Queensland  4103
				AU

7C-70-BC   (hex)		Lukup Media
C00000-CFFFFF     (base 16)		Lukup Media
				25/2 Norris Road
				Bangalore  Karnataka  560025
				IN

7C-70-BC   (hex)		dogtra
900000-9FFFFF     (base 16)		dogtra
				35, Namdongdong-ro 33beon-gil, Namdong-gu, Incheon,
				Seoul    KS006
				KR

14-1F-BA   (hex)		Deutsche Energieversorgung GmbH
200000-2FFFFF     (base 16)		Deutsche Energieversorgung GmbH
				Am Schenkberg 12
				Leipzig  Bundesland / Region wählen  04349
				DE

7C-70-BC   (hex)		HOPERUN MMAX DIGITAL PTE. LTD.
E00000-EFFFFF     (base 16)		HOPERUN MMAX DIGITAL PTE. LTD.
				152 BEACH ROAD
				  SINGAPORE  189721
				SG

7C-70-BC   (hex)		Mennekes Elektrotechnik GmbH & Co. KG
800000-8FFFFF     (base 16)		Mennekes Elektrotechnik GmbH & Co. KG
				Aloys-Mennekes-Str. 1
				Kirchhundem  NRW  57399
				DE

7C-70-BC   (hex)		Canary Connect, Inc.
500000-5FFFFF     (base 16)		Canary Connect, Inc.
				132 East 43rd Street
				New York  NY  10017
				US

BC-34-00   (hex)		Dexcel Design Pvt Ltd
400000-4FFFFF     (base 16)		Dexcel Design Pvt Ltd
				#138, Level 3,4 - Maruthi Tower
				Bangalore  Karnataka  560008
				IN

7C-70-BC   (hex)		Digital Lumens
200000-2FFFFF     (base 16)		Digital Lumens
				374 Congress Street, 6th Floor
				Boston  MA  02210
				US

A4-3B-FA   (hex)		JSC “Component-ASU”
D00000-DFFFFF     (base 16)		JSC “Component-ASU”
				Severnyi proezd 1, k. 5/6
				Chernogolovka  Moscow Region  142432
				

A4-3B-FA   (hex)		Maxon Australia
400000-4FFFFF     (base 16)		Maxon Australia
				36a Gibson Ave
				Padstow  New South Wales  2211
				AU

D0-76-50   (hex)		Revox Inc.
E00000-EFFFFF     (base 16)		Revox Inc.
				1880-2 Kamimizo, Chuo-ku,
				Sagamihara  Kanagawa  252-0243
				JP

A4-3B-FA   (hex)		Alpwise
800000-8FFFFF     (base 16)		Alpwise
				4 avenue Louis Doyen Weil
				Grenoble  Rhône-Alpes  38000
				FR

D0-76-50   (hex)		Picobrew LLC
600000-6FFFFF     (base 16)		Picobrew LLC
				2121 N 35th Street
				Seattle  WA  98103
				US

74-19-F8   (hex)		Ansjer Electronics Co., Ltd.
D00000-DFFFFF     (base 16)		Ansjer Electronics Co., Ltd.
				4 Bldg., Pinglan Indl. Park, Nanping,
				Zhuhai  Guangdong  519060
				CN

D0-76-50   (hex)		Annapurna Labs
500000-5FFFFF     (base 16)		Annapurna Labs
				1830 The Alameda
				San Jose  California  95126
				US

40-11-75   (hex)		BWT Tianjin Ltd.
A00000-AFFFFF     (base 16)		BWT Tianjin Ltd.
				1st Floor ,C Block,NO.225,Jinger Road ,Konggang Economic District,Tianjin 300308 ,China
				Tianjin    300000
				CN

4C-4B-F9   (hex)		Shenzhen Haichuan Intelligent Information Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Shenzhen Haichuan Intelligent Information Technology Co., Ltd.
				1208 District B,Jinhui Building, 2079 Nanhai Avenue,Dengliang Community,Nanshan Street,Nanshan District
				Shenzhen  Guangdong  518101
				CN

54-A4-93   (hex)		Advice
B00000-BFFFFF     (base 16)		Advice
				16 Atir Yeda St
				Kfar Saba  Not applicable  4464321
				IL

10-DC-B6   (hex)		Private
000000-0FFFFF     (base 16)		Private

54-A4-93   (hex)		Wonders Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Wonders Technology Co., Ltd.
				4/F,Tower A,3rd Building,Tian'an Cloud Park,Bantian Avenue,Longgang District
				Shenzhen    518129
				CN

04-D1-6E   (hex)		s.d.i. s.p.a.
200000-2FFFFF     (base 16)		s.d.i. s.p.a.
				Edison, 10
				Trezzano sul Naviglio  Milano  20090
				IT

04-D1-6E   (hex)		FUZHOU ZHUOYI ELECTRONIC CO.,LTD
900000-9FFFFF     (base 16)		FUZHOU ZHUOYI ELECTRONIC CO.,LTD
				NO.22 BAIHUAZHOU ROAD,FUZHOU,FUJIAN,CHINA
				FUZHOU  FUJIAN  350008
				CN

54-A4-93   (hex)		Do Easy International Limited
900000-9FFFFF     (base 16)		Do Easy International Limited
				No. 107, Wenjian St., Fengshan Dist.
				Kaohsiung    83067
				TW

54-A4-93   (hex)		RED Hydrogen LLC
700000-7FFFFF     (base 16)		RED Hydrogen LLC
				15 Cushing
				IRVINE  CA  92618
				US

44-03-77   (hex)		Norden Communication UK Ltd.
500000-5FFFFF     (base 16)		Norden Communication UK Ltd.
				Unit-13, Baker Close, Oakwood Business Park
				Clacton-On-Sea  Essex  CO15 4BD
				GB

44-03-77   (hex)		symplr
A00000-AFFFFF     (base 16)		symplr
				1550 Innovation Way
				Hartford  WI  53027
				US

44-03-77   (hex)		Musashi Seimitsu Industry Co.,Ltd
000000-0FFFFF     (base 16)		Musashi Seimitsu Industry Co.,Ltd
				39-5 Daizen,Ueta-cho
				Toyohashi  Aichi  441-8560
				JP

44-03-77   (hex)		Annapurna labs
300000-3FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

50-62-55   (hex)		CCTV Manufacturer
A00000-AFFFFF     (base 16)		CCTV Manufacturer
				Room 1807,Bagua 4 Rd,Futian District
				Shenzhen  Guangdong  518029
				CN

50-62-55   (hex)		Roda industrial development Co.,Ltd.
800000-8FFFFF     (base 16)		Roda industrial development Co.,Ltd.
				2-3F,Building C,Unistar Park,GenYu Road,GuangMing New District
				Shenzhen    518000
				CN

50-62-55   (hex)		Hagiwara Solutions Co., Ltd 
100000-1FFFFF     (base 16)		Hagiwara Solutions Co., Ltd 
				7F, Sakae TV BLD, 3-10-32, Nishiki, Naka-ku,
				Nagoya City  Aichi Prefecture  460-0003
				JP

64-31-39   (hex)		Shenzhen He&e Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Shenzhen He&e Technology Co.,Ltd.
				2nd Floor, Building A7, Shenzhen Low Carbon Technology Demonstration Park, Silicon Valley Power, Guiyue Road, Guanlan Street, Longhua District, Shenzhen, China
				ShenZhen    518100
				CN

64-31-39   (hex)		Shenzhen Huanyin Electronics Ltd.
800000-8FFFFF     (base 16)		Shenzhen Huanyin Electronics Ltd.
				Room 1707, 17/F, West Block, Nanshan Digital Culture Industrial Base, Nanshan District
				Shenzhen  Guangdong  519052
				CN

64-31-39   (hex)		Product Development Associates, Inc.
A00000-AFFFFF     (base 16)		Product Development Associates, Inc.
				1145 E. Cliff Rd
				Burnsville  MN  55337
				US

C4-95-4D   (hex)		Newland Era Edu Hi-Tech(BeiJing)Co.,Ltd
D00000-DFFFFF     (base 16)		Newland Era Edu Hi-Tech(BeiJing)Co.,Ltd
				No. 1, Linkong 2 Road,North Wenhuaying Village, Gaoliying Town, Shunyi District, Beijing
				Beijing    101303
				CN

64-31-39   (hex)		Smartplus Inc.
200000-2FFFFF     (base 16)		Smartplus Inc.
				415 steelcase road east
				markham  Ontario  L3R1G3
				CA

C4-95-4D   (hex)		Multicom, Inc
B00000-BFFFFF     (base 16)		Multicom, Inc
				1076 Florida Central Parkway
				Longwood  FL  32750
				US

00-69-67   (hex)		PANGAEA SOLUTION INC
700000-7FFFFF     (base 16)		PANGAEA SOLUTION INC
				774, Yuseong-daero, Yuseong-gu, 
				Daejeon  Daejeon  34171
				KR

00-69-67   (hex)		Command Alkon, Inc
400000-4FFFFF     (base 16)		Command Alkon, Inc
				1800 International Park Dr., Ste 400
				Birmingham  AL  35243
				US

C4-95-4D   (hex)		Canare Electric Co., Ltd.
E00000-EFFFFF     (base 16)		Canare Electric Co., Ltd.
				B-13F,Shiba Park Bldg.,2-4-1,Shiba-Koen
				Minato  Tokyo  105-0011
				JP

00-69-67   (hex)		Desird Design R&D
C00000-CFFFFF     (base 16)		Desird Design R&D
				Mehmetçik Mahallesi Aspendos Bulvar? No:99A Muratpa?a/ANTALYA
				Antalya    07300
				TR

A0-22-4E   (hex)		Kyung In Electronics
000000-0FFFFF     (base 16)		Kyung In Electronics
				#1411, Byucksan Digital Valley 2, 184, Gasan Digital2-ro, Geumcheon-gu
				 Seoul    08501
				KR

A0-22-4E   (hex)		EISST  International Ltd
800000-8FFFFF     (base 16)		EISST  International Ltd
				10 Queen Street Place
				London  London  EC4R 1AG
				GB

20-0A-0D   (hex)		Wideband Systems, Inc.
100000-1FFFFF     (base 16)		Wideband Systems, Inc.
				11900 Bournefield Way STE 120
				Silver Spring  MD  20904
				US

20-0A-0D   (hex)		sehwa
C00000-CFFFFF     (base 16)		sehwa
				231, Techno 2-ro, Yuseong-gu, Daejeon, Republic of Korea
				Daejeon  Daejeon  34026
				KR

20-0A-0D   (hex)		Shenzhen Zhangyue Technology Co.,Ltd 
500000-5FFFFF     (base 16)		Shenzhen Zhangyue Technology Co.,Ltd 
				Nanshan District Yuehai Street Weixin Software Science Park Building 8 9th Floor Room 903
				Shenzhen  Guangdong  518500
				CN

40-2C-76   (hex)		Guangzhou Qi'an Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Guangzhou Qi'an Technology Co., Ltd.
				No. 3, Dasonggang, Jiangnan Avenue Middle Road, Haizhu District, Guangzhou (office only)
				Guangzhou  Guangdong  510220
				CN

40-2C-76   (hex)		Beijing Kuaiyu Electronic Co., Ltd.
B00000-BFFFFF     (base 16)		Beijing Kuaiyu Electronic Co., Ltd.
				Kuaiyu Technologies, Building 11, Yuquan Huigu, Tsinghua Science Park, No. 3 Minzhuang Road, Haidian District, Beijing
				Beijing    100195
				CN

50-DE-19   (hex)		Langogo Technology Co., Ltd.
400000-4FFFFF     (base 16)		Langogo Technology Co., Ltd.
				 2/F, Boxun Building, Keyuan North Road, Nanshan District
				Shenzhen  Guangdong  518103
				CN

3C-FA-D3   (hex)		GRG Banking Technology Co.,Ltd
400000-4FFFFF     (base 16)		GRG Banking Technology Co.,Ltd
				232 Gaotang Road,Tianhe District
				Guangzhou  Guangdong  510000
				CN

3C-FA-D3   (hex)		UltiMachine
A00000-AFFFFF     (base 16)		UltiMachine
				200 12th St. N.
				South Pittsburg  TN  37380
				US

3C-FA-D3   (hex)		Harman Connected Services, Inc.
300000-3FFFFF     (base 16)		Harman Connected Services, Inc.
				636 Ellis Street Mountain View
				New York  CA  10003
				US

B0-B3-53   (hex)		Rizhao SUNWAM International Co., Ltd.
200000-2FFFFF     (base 16)		Rizhao SUNWAM International Co., Ltd.
				No.001-00-114, Ruiyuan Mingcheng, Haiqu Zhong Road
				Rizhao  Shandong  276800
				CN

B0-B3-53   (hex)		Ledger
A00000-AFFFFF     (base 16)		Ledger
				1 rue du mail
				Paris    75002
				FR

14-AE-85   (hex)		Trimble LEM
800000-8FFFFF     (base 16)		Trimble LEM
				10368 Westmoor Dr
				Westminster  CO  80021
				US

14-AE-85   (hex)		Kayamatics Limited
000000-0FFFFF     (base 16)		Kayamatics Limited
				Room 1209, Trend Centre, 29 Cheung Lee Street
				Chaiwan  NA  NA
				HK

64-62-66   (hex)		Shenzhen C & D Electronics Co., Ltd.
700000-7FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

64-62-66   (hex)		Signal Hound
B00000-BFFFFF     (base 16)		Signal Hound
				1502 SE Commerce Ave Suite 101
				Battle Ground  WA  98604
				US

64-62-66   (hex)		Chunghwa System Integration Co., Ltd.
900000-9FFFFF     (base 16)		Chunghwa System Integration Co., Ltd.
				2F., No. 35, Aiguo E. Rd.,
				Taipei    106
				TW

64-62-66   (hex)		Protectli
200000-2FFFFF     (base 16)		Protectli
				1315 Hot Springs Way
				Vista  CA  92081
				US

64-62-66   (hex)		Redstone Systems, Inc.
400000-4FFFFF     (base 16)		Redstone Systems, Inc.
				24 School Street, 2nd floor
				Boston    02108
				US

64-62-66   (hex)		Kobol Innovations Pte. Ltd.
D00000-DFFFFF     (base 16)		Kobol Innovations Pte. Ltd.
				101 Cecil Street, #26-01/07 Tong Eng Building
				Singapore    069533
				SG

94-05-BB   (hex)		AUSTAR HEARING SCIENCE AND TECHNILIGY(XIAMEN)CO.,LTD
B00000-BFFFFF     (base 16)		AUSTAR HEARING SCIENCE AND TECHNILIGY(XIAMEN)CO.,LTD
				RM201,No.2Gaoqi South 12th Road,HuliDist
				XIamen  Fujian  361006
				CN

94-05-BB   (hex)		LAO INDUSTRIA LTDA
C00000-CFFFFF     (base 16)		LAO INDUSTRIA LTDA
				AV DR MAURO LINDENBERG MONTEIRO, 1003
				OSASCO  SÃO PAULO  06278010
				BR

F4-90-CB   (hex)		Avilution
500000-5FFFFF     (base 16)		Avilution
				103 Shoreline Dr
				Madison  AL  35758
				US

F4-90-CB   (hex)		OmniNet
400000-4FFFFF     (base 16)		OmniNet
				6410 Del Rio Rd
				Charlotte  NC  28277
				US

F4-90-CB   (hex)		Epitel, Inc.
000000-0FFFFF     (base 16)		Epitel, Inc.
				630 S. Stringfellow Ct., Unit #B
				Salt Lake City  UT  84111
				US

F4-90-CB   (hex)		Fractyl Labs
900000-9FFFFF     (base 16)		Fractyl Labs
				17 HARTWELL AVE
				LEXINGTON  MA  02421
				US

C0-9B-F4   (hex)		JSC NPK ATRONIK
400000-4FFFFF     (base 16)		JSC NPK ATRONIK
				VARSHAVSKOE SH, 118-1-P XLII K4 10
				Moscow  Moscow  117587
				RU

C0-9B-F4   (hex)		Pinpark Inc.
C00000-CFFFFF     (base 16)		Pinpark Inc.
				9F., No. 101, Sec. 2, Nanjing E. Rd.,, Zhongshan Dist.,
				Taipei  Taiwan  104
				TW

C0-9B-F4   (hex)		NUCTECH COMPANY LIMITED
B00000-BFFFFF     (base 16)		NUCTECH COMPANY LIMITED
				 2/F Block A,Tongfang Building,Shuangqinglu,Haidian District
				Beijing  Beijing  100084
				CN

C0-9B-F4   (hex)		Osprey Video, Inc
300000-3FFFFF     (base 16)		Osprey Video, Inc
				1628 Valwood Parkway Suite 200
				Carrollton  TX  75006
				US

E8-B4-70   (hex)		internet domain name system beijing engineering research center ltd
200000-2FFFFF     (base 16)		internet domain name system beijing engineering research center ltd
				4,4TH SOUTH STREET ZHONG GUAN CUN
				hai dian qu ,beijing  BEIJING  100190
				CN

E8-B4-70   (hex)		DongGuan Ramaxel Memory Technology
000000-0FFFFF     (base 16)		DongGuan Ramaxel Memory Technology
				No.32, Industrial East Road,Innovation Park, High-tech Industrial Development Zone, Songshan Lake, Dongguan City, Guangdong Province,China
				DongGuan  Guangdong  523808
				CN

C0-9B-F4   (hex)		Infiot Inc.
500000-5FFFFF     (base 16)		Infiot Inc.
				75 E. Santa Clara St., Suite 600
				San Jose  CA  95113
				US

E8-B4-70   (hex)		plc2 Design GmbH
A00000-AFFFFF     (base 16)		plc2 Design GmbH
				Hugstmattweg 30
				Freiburg i. Br.    79112
				DE

E8-B4-70   (hex)		Miltek Industries Pte Ltd
900000-9FFFFF     (base 16)		Miltek Industries Pte Ltd
				62 Ubi Road 1 #10-03, Oxley Bizhub 2. Singapore 408734
				Singapore    408734
				SG

E8-B4-70   (hex)		DEHN SE + Co KG
800000-8FFFFF     (base 16)		DEHN SE + Co KG
				Hans-Dehn-Straße 1
				Neumarkt  Bavaria  92318
				DE

E8-B4-70   (hex)		Alperia Fiber srl 
500000-5FFFFF     (base 16)		Alperia Fiber srl 
				Via Dodiciville 8
				Bolzano   bz  39100
				IT

E8-B4-70   (hex)		Elcoma
600000-6FFFFF     (base 16)		Elcoma
				Rua Barbosa Lima, 149
				Recife  Pernambuco  50030-330
				BR

38-F7-CD   (hex)		APT MOBILE SATCOM LIMITED
E00000-EFFFFF     (base 16)		APT MOBILE SATCOM LIMITED
				18th Floor, Building C, Shenye U Center, Zhoushi Road, Baoan District
				Shenzhen  Guangdong  518000
				CN

70-69-79   (hex)		Linksys Telecom Shenzhen CO., LTD
100000-1FFFFF     (base 16)		Linksys Telecom Shenzhen CO., LTD
				RoomC303-A, Number 2223 road Banxuegang Xinweizai Gangtou Community Bantian street
				Longgang Township  Guangdong  514349
				CN

70-69-79   (hex)		FREUND ELEKTRONIKA D.O.O., IP-INTEGRA TECHNOLOGIES
D00000-DFFFFF     (base 16)		FREUND ELEKTRONIKA D.O.O., IP-INTEGRA TECHNOLOGIES
				HAMDIJE KRESEVLJAKOVICA 18
				SARAJEVO    71000
				BA

CC-C2-61   (hex)		Nortek Security & Control
C00000-CFFFFF     (base 16)		Nortek Security & Control
				5919 Sea Otter Place
				Carlsbad  CA  92010
				US

CC-C2-61   (hex)		Guardiar USA
600000-6FFFFF     (base 16)		Guardiar USA
				3309 S Kaufman St
				Ennis  TX  75119
				US

CC-C2-61   (hex)		Winterthur Gas & Diesel Ltd.
B00000-BFFFFF     (base 16)		Winterthur Gas & Diesel Ltd.
				Schützenstrasse 3
				Winterthur    8401
				CH

CC-C2-61   (hex)		NETRADYNE, INC.
300000-3FFFFF     (base 16)		NETRADYNE, INC.
				9191 TOWNE CENTRE DR STE 200
				SAN DIEGO  CA  92122
				US

CC-C2-61   (hex)		NWL Inc.
100000-1FFFFF     (base 16)		NWL Inc.
				312 Rising Sun Road
				Bordentown  NJ  08505
				US

F0-D7-AF   (hex)		New IT Project LLC
900000-9FFFFF     (base 16)		New IT Project LLC
				Nagatinskaya St. 16, bld. 9, space VII, room 15, office 5
				Moscow    115487
				RU

F0-D7-AF   (hex)		Dongguan Huili electroacoustic Industrial Co.,ltd
500000-5FFFFF     (base 16)		Dongguan Huili electroacoustic Industrial Co.,ltd
				Dalang Town, Biyun Cai Bai Cun East Second Street 66,A4 Building 501
				Dongguan  Guangdong  523770
				CN

F0-D7-AF   (hex)		Blacknight Internet Solutions Limited
200000-2FFFFF     (base 16)		Blacknight Internet Solutions Limited
				Unit 12a, Barrowside Business Park, Sleaty Rd.
				Carlow  Carlow  R93 X265
				IE

F0-D7-AF   (hex)		MSTAR TECHNOLOGIES,INC
A00000-AFFFFF     (base 16)		MSTAR TECHNOLOGIES,INC
				#998 West Wenyi Road
				Hangzhou  Zhejiang  310012
				CN

30-49-50   (hex)		SHENZHEN LDROBOT CO., LTD.
800000-8FFFFF     (base 16)		SHENZHEN LDROBOT CO., LTD.
				Nanshan
				Shenzhen    518000
				CN

D0-14-11   (hex)		Video Security, Inc.
800000-8FFFFF     (base 16)		Video Security, Inc.
				No. 59, Cinghua St. San Min Dist.
				Kaohsiung, Taiwan, R.O.C.  Kaohsiung City  807
				TW

D0-14-11   (hex)		Realwave Inc.
700000-7FFFFF     (base 16)		Realwave Inc.
				5857 Owens Avenue, Suite 300
				Carlsbad  CA  92008-5507
				US

D0-14-11   (hex)		Tecnosoft srl
E00000-EFFFFF     (base 16)		Tecnosoft srl
				via Galvani, 4
				Peschiera Borromeo  Milan  20068
				IT

5C-85-7E   (hex)		BeiJing Xinsheng Technology Co.,Ltd
800000-8FFFFF     (base 16)		BeiJing Xinsheng Technology Co.,Ltd
				1-1827, East (LIANHANG building), chaichangtun village, Yongledian Town, Tongzhou District
				BeiJing  BeiJing  250100
				CN

5C-85-7E   (hex)		HHCC Plant Technology Co., Ltd.
B00000-BFFFFF     (base 16)		HHCC Plant Technology Co., Ltd.
				RM626, 6th Floor, Zhongguoleshili,’,#35 Xiaoyun Road, Chaoyang District,Beijing, China
				Beijing  Beijing  100028
				CN

D0-14-11   (hex)		iLOQ Oy
300000-3FFFFF     (base 16)		iLOQ Oy
				Yrttipellontie 10
				Oulu  EMEA  90230
				FI

5C-85-7E   (hex)		28 Gorilla
000000-0FFFFF     (base 16)		28 Gorilla
				12 S San Marcos Pl
				Chandler  AZ  85225
				US

F4-69-D5   (hex)		Konntek Inc
B00000-BFFFFF     (base 16)		Konntek Inc
				3600 F-X Tessier, Unit #H
				Vaudreuil  Quebec  J7V 5V5
				CA

F4-69-D5   (hex)		Hefei STAROT Technology Co.,Ltd
500000-5FFFFF     (base 16)		Hefei STAROT Technology Co.,Ltd
				406, 4th Floor, Quality Control Building, Saipu Science Park, No. 6 Yunfei Road, High-tech Zone
				hefei  anhui  230000
				CN

F4-69-D5   (hex)		ORtek Technology, Inc.
E00000-EFFFFF     (base 16)		ORtek Technology, Inc.
				13F, no.150, Jian-Yi Rd., ZhongHe Dist.
				New Taipei City  Taiwan  23511
				TW

F4-69-D5   (hex)		TianJin KCHT Information Technology Co., Ltd.
600000-6FFFFF     (base 16)		TianJin KCHT Information Technology Co., Ltd.
				1704 Huicheng Technology Building, No. 65 Pioneer Road, Dongli District
				Tianjin    300000
				CN

4C-93-A6   (hex)		Felten Electronics
B00000-BFFFFF     (base 16)		Felten Electronics
				Wilhelmstrasse 43
				Aachen  NRW  52070
				DE

4C-93-A6   (hex)		Advantics
900000-9FFFFF     (base 16)		Advantics
				55C Rue Auguste Piccard
				Saint-Genis-Pouilly    01630
				FR

28-B7-7C   (hex)		GROTHE GmbH
500000-5FFFFF     (base 16)		GROTHE GmbH
				Loehestrasse 22
				Hennef    53773
				DE

28-B7-7C   (hex)		SHENZHEN EVIEW GPS TECHNOLOGY
000000-0FFFFF     (base 16)		SHENZHEN EVIEW GPS TECHNOLOGY
				Rm 201, building 1-A, Nankechuang Industrial Park, Gaofeng Road, Longhua district
				Shenzhen  Guangdong  518109
				CN

28-B7-7C   (hex)		Beijing Kitten&Puppy Technology Co.,Ltd.
300000-3FFFFF     (base 16)		Beijing Kitten&Puppy Technology Co.,Ltd.
				Room Q-101? Floor 2?Q Area, Anningzhuang Back Street?Haidian District
				Beijing    100096
				CN

28-B7-7C   (hex)		Simaudio Ltd
A00000-AFFFFF     (base 16)		Simaudio Ltd
				1345 rue Newton
				Boucherville  Quebec  J4B 5H2
				CA

28-B7-7C   (hex)		Vehant Technologies Pvt Ltd.
B00000-BFFFFF     (base 16)		Vehant Technologies Pvt Ltd.
				Plot no. 97, Ecotech-12, block-Ecotech -12, Sector-Noida Extension
				Greater Noida  Uttar Pradesh  201310
				IN

C0-61-9A   (hex)		Victron Energy B.V.
B00000-BFFFFF     (base 16)		Victron Energy B.V.
				De Paal 35
				Almere    1351JG
				NL

C0-61-9A   (hex)		Grup Arge Enerji ve Kontrol Sistemleri
200000-2FFFFF     (base 16)		Grup Arge Enerji ve Kontrol Sistemleri
				?kitelli OSB Mah. YTÜ ?kitelli Teknopark Sok. No:1 / 2B01-2B07-2B08-2B09
				?stanbul  ?STANBUL  34490
				TR

C0-61-9A   (hex)		IPG Automotive GmbH
600000-6FFFFF     (base 16)		IPG Automotive GmbH
				Bannwaldallee 60
				Karlsruhe    76185
				DE

98-FC-84   (hex)		Fath Mechatronics
900000-9FFFFF     (base 16)		Fath Mechatronics
				Hügelmühle 31
				Spalt  bavaria  91174
				DE

98-FC-84   (hex)		Broadtech Technologies Co., Ltd.
700000-7FFFFF     (base 16)		Broadtech Technologies Co., Ltd.
				No. 1, Area A, 3rd Floor, Building B1, Shenzhen Digital Technology Park, No. 002, Gaoxin South Seventh Road, Nanshan District,
				Shenzhen  GuangDong  518057
				CN

98-FC-84   (hex)		Dongguan Kingtron Electronics Tech Co., Ltd
E00000-EFFFFF     (base 16)		Dongguan Kingtron Electronics Tech Co., Ltd
				No.3 Fumin North Rd,Shu'an Industrial Park, Humen Town
				Dongguan  Guangdong China  523929
				CN

18-FD-CB   (hex)		StreamLocator
D00000-DFFFFF     (base 16)		StreamLocator
				200-155 East Beaver Creek Rd
				Richmond Hill  ON  L4B 2N1
				CA

18-FD-CB   (hex)		Gosuncn Technology Group Co.,LTD.
400000-4FFFFF     (base 16)		Gosuncn Technology Group Co.,LTD.
				6F,2819 KaiChuang Blvd.,Science Town,Huangpu District
				Guangzhou City  Guangdong  510530
				CN

58-20-8A   (hex)		Aggregate Co.,Ltd.
300000-3FFFFF     (base 16)		Aggregate Co.,Ltd.
				Toso Building 4F, 1-9-8 Yayoi-cho
				nakano-ku  tokyo  164-0013
				JP

58-20-8A   (hex)		MARS DIGI TECH CO .,LTD
200000-2FFFFF     (base 16)		MARS DIGI TECH CO .,LTD
				RM 2314,Build No.B2,GuiMiao Road,NanShan District
				ShenZhen  Guangdong  518054
				CN

58-20-8A   (hex)		pureLiFi Ltd
700000-7FFFFF     (base 16)		pureLiFi Ltd
				Rosebery House, 9 Haymarket Terrace
				Edinburgh    EH12 5EZ
				GB

CC-4F-5C   (hex)		Feelmore Labs
800000-8FFFFF     (base 16)		Feelmore Labs
				370 Jay Street, Floor 7
				Brooklyn  NY  11201
				US

FC-CD-2F   (hex)		HEAD-DIRECT (KUNSHAN) Co. Ltd
B00000-BFFFFF     (base 16)		HEAD-DIRECT (KUNSHAN) Co. Ltd
				Kunshan Bacheng West Yingbing Rd. shangkunzhichuang chanyeyuan C2#
				Suzhou  Jiangsu  215311
				CN

58-E8-76   (hex)		Zhuhai Raysharp Technology Co.,Ltd
000000-0FFFFF     (base 16)		Zhuhai Raysharp Technology Co.,Ltd
				No.100 of Keji Liu Rd.6, Hi-Tech Zone
				Zhuhai  Guangdong   519080
				CN

FC-CD-2F   (hex)		Annapurna labs
600000-6FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

FC-CD-2F   (hex)		Asesorias y Servicios Innovaxxion SPA
800000-8FFFFF     (base 16)		Asesorias y Servicios Innovaxxion SPA
				Alonso de Cordova 5320, of 1403, Las condes
				Santiago  RM  7550000
				CL

FC-CD-2F   (hex)		Suzhou lehui display co.,ltd
700000-7FFFFF     (base 16)		Suzhou lehui display co.,ltd
				?225 Jinfeng Road?Suzhou New District?Jiangsu Province
				suzhou    215129
				CN

58-95-D8   (hex)		Shenzhen C & D Electronics Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

FC-CD-2F   (hex)		Eltek brojila d.o.o.
E00000-EFFFFF     (base 16)		Eltek brojila d.o.o.
				Svetice 24
				Zagreb    10000
				HR

58-95-D8   (hex)		Tonnet Telecommunication International Co., Ltd.
300000-3FFFFF     (base 16)		Tonnet Telecommunication International Co., Ltd.
				10F,No.6,Ln.609,Sec.5 Chongxin Rd., Sanchong Dist.
				New Taipei    241
				TW

58-95-D8   (hex)		Gmv sistemas SAU
E00000-EFFFFF     (base 16)		Gmv sistemas SAU
				C/ Juan Herrera 17 P.T.B. ,Parcela 101
				Boecillo  Valladolid  47151 
				ES

58-95-D8   (hex)		Unity Surveillance, Inc.
400000-4FFFFF     (base 16)		Unity Surveillance, Inc.
				629 East Grand Ave
				Hot Springs National Park  AR  71901
				US

DC-4A-9E   (hex)		ADIAL
400000-4FFFFF     (base 16)		ADIAL
				87 Rue Alexandre Fleming
				LISIEUX    14100
				FR

DC-4A-9E   (hex)		Advanced Electronics Ltd
100000-1FFFFF     (base 16)		Advanced Electronics Ltd
				Balliol Business Park
				Newcastle    NE12 8EW
				GB

DC-4A-9E   (hex)		SES-imagotag Deutschland GmbH
E00000-EFFFFF     (base 16)		SES-imagotag Deutschland GmbH
				Bundesstrasse 16
				Ettenheim  BW  77955
				DE

DC-4A-9E   (hex)		HEFEI DATANG STORAGE TECHNOLOGY CO.,LTD
C00000-CFFFFF     (base 16)		HEFEI DATANG STORAGE TECHNOLOGY CO.,LTD
				7F BLOCK C J2 BUILDING INNOVATION PARK HIGH TECH DISTRICT
				HEFEI  AN HUI PROVINCE PR CHINA  220038
				CN

84-11-C2   (hex)		igus GmbH
A00000-AFFFFF     (base 16)		igus GmbH
				Spicher Str. 1a
				Köln    51147
				DE

68-79-12   (hex)		Neurolab
D00000-DFFFFF     (base 16)		Neurolab
				Naberezhnaya Shlyuzovaya, d. 6, str. 3, et. 3, pom. 1
				Moscow  -  115114
				RU

84-11-C2   (hex)		KESSEL AG
600000-6FFFFF     (base 16)		KESSEL AG
				Bahnhofstraße 31
				Lenting    85101
				DE

68-79-12   (hex)		Annapurna labs
100000-1FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

68-79-12   (hex)		McDonald's Corporation
400000-4FFFFF     (base 16)		McDonald's Corporation
				110 N. Carpenter Street
				Chicago    60607
				US

8C-47-6E   (hex)		Oxford Nanopore Technologies Ltd.
600000-6FFFFF     (base 16)		Oxford Nanopore Technologies Ltd.
				Gosling Building, Edmund Halley Road, Oxford Science Park
				Oxford  Oxfordshire  OX4 4DQ
				GB

8C-47-6E   (hex)		innolectric AG
D00000-DFFFFF     (base 16)		innolectric AG
				Universitaetsstr. 136
				Bochum    44799 
				DE

C0-61-9A   (hex)		Stello
400000-4FFFFF     (base 16)		Stello
				9995 Rue de Châteauneuf (Local V)
				Brossard  Quebec  J4Z 3V7
				CA

8C-AE-49   (hex)		Larch Networks
D00000-DFFFFF     (base 16)		Larch Networks
				11 Amal Str.
				Rosh Ain    4809239
				IL

A4-53-EE   (hex)		T-Touching Co., Ltd.
800000-8FFFFF     (base 16)		T-Touching Co., Ltd.
				28B, No. 4, Science and Technology 10th Road
				Dongguan  GuangDong  52300
				CN

A0-02-4A   (hex)		Zhejiang Hechuan Technology Co.,Ltd
000000-0FFFFF     (base 16)		Zhejiang Hechuan Technology Co.,Ltd
				No. 9, Fucai Road, Longyou Industrial Zone, Quzhou City, Zhejiang Province, PRC
				Quzhou    324000
				CN

A4-53-EE   (hex)		Beijing Lanke Science and Technology Co.,LTd.
700000-7FFFFF     (base 16)		Beijing Lanke Science and Technology Co.,LTd.
				Room 607, building 6, No.1, Chaoqian Road, science and Technology Park, Changping District
				Beijing     102209
				CN

A0-02-4A   (hex)		bitbee Inc
D00000-DFFFFF     (base 16)		bitbee Inc
				#703, 361 Simindae-ro, Dongan-gu,
				anyang-si  gyeonggi-do  14057
				KR

A0-02-4A   (hex)		SomaDetect Inc
300000-3FFFFF     (base 16)		SomaDetect Inc
				241 Canada Street, Suite 10 
				Fredericton  New Brunswick  E3A 4A1
				CA

78-D4-F1   (hex)		BONENG TRANSMISSION(SUZHOU)CO.,LTD
A00000-AFFFFF     (base 16)		BONENG TRANSMISSION(SUZHOU)CO.,LTD
				100#Ruyuan Rd.,Xiangcheng District,
				Suzhou  Jiangsu  215131
				CN

78-D4-F1   (hex)		Lyngsoe Systems
200000-2FFFFF     (base 16)		Lyngsoe Systems
				101 Simona Dr Unit 2
				Bolton  Ontario  L7E 4E8
				CA

78-D4-F1   (hex)		Blue Sparq, Inc.
E00000-EFFFFF     (base 16)		Blue Sparq, Inc.
				928 NE 24th Lane, Unit 4
				Cape Coral  FL  33909
				US

44-6F-D8   (hex)		SCAIME
D00000-DFFFFF     (base 16)		SCAIME
				294 Rue Georges Charpak
				JUVIGNY  Select State  74100
				FR

44-6F-D8   (hex)		Anhui GuDao Tech
600000-6FFFFF     (base 16)		Anhui GuDao Tech
				Dangtu Qingshanhe
				MaAnShan  AnHui  243000
				CN

44-6F-D8   (hex)		Annapurna labs
900000-9FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

98-27-82   (hex)		SHENZHEN HEROFUN BIO-TECH CO., LTD
000000-0FFFFF     (base 16)		SHENZHEN HEROFUN BIO-TECH CO., LTD
				7001B, 7th Floor, LaoBing Building, East Block 2, No. 3012 XingYe Road, BaoAn District
				Shenzhen    518100
				CN

98-27-82   (hex)		RayTron, INC.
B00000-BFFFFF     (base 16)		RayTron, INC.
				11F.ESLEAD Bldg.HONMACHI 1-4-8 HONMACHI CHUO-KU
				Osaka  Osaka  541-0053
				JP

98-27-82   (hex)		Thorlabs GmbH
D00000-DFFFFF     (base 16)		Thorlabs GmbH
				Münchner Weg 1
				Bergkirchen    85232
				DE

98-27-82   (hex)		WESTERN SECURITY SOLUTIONS
600000-6FFFFF     (base 16)		WESTERN SECURITY SOLUTIONS
				WSS TOWER HARINAGAR
				GURUGRAM  HARYANA  122001
				IN

98-27-82   (hex)		Danfoss Power Solutions
300000-3FFFFF     (base 16)		Danfoss Power Solutions
				3500 Annapolis Lane N
				Minneapolis  MN  55447
				US

04-11-19   (hex)		AC Power Distribution / ACT Entmt.
900000-9FFFFF     (base 16)		AC Power Distribution / ACT Entmt.
				2313 N. Valley St.
				Burbank  CA  91505
				US

04-11-19   (hex)		CyOne Security AG
A00000-AFFFFF     (base 16)		CyOne Security AG
				Hinterbergstrasse 18
				Steinhausen  Zug  6312
				CH

04-11-19   (hex)		SUZHOU RIBAO TECHNOLOGY CO.,LTD.
300000-3FFFFF     (base 16)		SUZHOU RIBAO TECHNOLOGY CO.,LTD.
				SUZHOU RIBAO TECHNOLOGY CO.,LTD.
				SUZHOU  JIANGSU  215133
				CN

04-11-19   (hex)		Nuance Hearing Ltd.
D00000-DFFFFF     (base 16)		Nuance Hearing Ltd.
				Raoul Wallenberg 24, Building A1, Floor 3
				Tel Aviv    6971920
				IL

E8-6C-C7   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

E8-6C-C7   (hex)		Shenzhen Yibaifen Industrial Co.,Ltd.
300000-3FFFFF     (base 16)		Shenzhen Yibaifen Industrial Co.,Ltd.
				501/501, Building 2, Hongxiang Industrial Park, 21 Huancheng South Road, Ma'antang Community, Bantian Street, Longgang District, Shenzhen
				Shenzhen    518000
				CN

E8-6C-C7   (hex)		z-max mediasolution
D00000-DFFFFF     (base 16)		z-max mediasolution
				Surugadai Bldg.8F kanda surugadai 1-7-10
				Chiyodaku  Tokyo  101-0062
				JP

DC-E5-33   (hex)		Amazinglayer Network Co., Ltd.
A00000-AFFFFF     (base 16)		Amazinglayer Network Co., Ltd.
				Room118, Building B, JinTaiHuaYun Building, WuGenLin HuTong 11
				Beijing  Beijing  100035
				CN

24-5D-FC   (hex)		ARTICONA - Bechtle Logistik & Service GmbH
100000-1FFFFF     (base 16)		ARTICONA - Bechtle Logistik & Service GmbH
				Bechtle Platz 1
				Neckarsulm  Baden-Württemberg  74172
				DE

24-5D-FC   (hex)		Blue Iris Labs
200000-2FFFFF     (base 16)		Blue Iris Labs
				18 Acacia Rd
				Fairfax  CA  94930
				US

24-5D-FC   (hex)		LTY LLC
700000-7FFFFF     (base 16)		LTY LLC
				1321 UPLAND DR
				HOUSTON  TX  77043
				US

60-15-92   (hex)		PSS Co., Ltd
C00000-CFFFFF     (base 16)		PSS Co., Ltd
				4F., No. 10, Ln. 327, Sec. 2, Zhongshan Rd., Zhonghe Dist.
				New Taipei City  ???  235
				TW

60-15-92   (hex)		RTDS Technologies Inc.
100000-1FFFFF     (base 16)		RTDS Technologies Inc.
				100-150 Innovation Drive
				Winnipeg  Manitoba  R3T 2E1
				CA

60-15-92   (hex)		JIANGSU SUNFY TECHNOLOGIES HOLDING CO.,LTD.
900000-9FFFFF     (base 16)		JIANGSU SUNFY TECHNOLOGIES HOLDING CO.,LTD.
				Building 6, No. 1088, Jiangcheng Road, Sutong Technology Industrial Park
				Nantong  Jiangsu  226017
				CN

60-15-92   (hex)		OSI TECHNOLOGY CO.,LTD.
300000-3FFFFF     (base 16)		OSI TECHNOLOGY CO.,LTD.
				No.74, Fenyang Rd., Sanmin Dist.
				Kaohsiung City  Taiwan  807
				TW

60-15-92   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

0C-5C-B5   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

0C-5C-B5   (hex)		Shenzhen C & D Electronics Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

0C-5C-B5   (hex)		iH&S Technology Limited
300000-3FFFFF     (base 16)		iH&S Technology Limited
				iH&S Technology Limited
				7/F, Unify Commercial & Ind. Bldg., 31 Tai Yip Street, Kwun Tong  Hong Kong  999077
				HK

0C-5C-B5   (hex)		Energybox Limited
700000-7FFFFF     (base 16)		Energybox Limited
				8/F., Green 18, HK Science Park
				Sha Tin  Hong Kong   0000
				HK

1C-A0-EF   (hex)		HANJEN.CHIN  CO., LTD.
600000-6FFFFF     (base 16)		HANJEN.CHIN  CO., LTD.
				Fl.2 No. 101  Jian 1st Rd., Zhonghe Dist., 
				NEW TAIPEI CITY  TAIWAN  235
				TW

0C-5C-B5   (hex)		Colordeve International
900000-9FFFFF     (base 16)		Colordeve International
				601, block B, Logistics Park, Yihong Road, Yantian village, Fenggang Town, DG, GD, China
				Dongguan City    523702
				CN

20-CE-2A   (hex)		Beijing Huadianzhongxin Tech.Co.,Ltd
700000-7FFFFF     (base 16)		Beijing Huadianzhongxin Tech.Co.,Ltd
				Room 318,the 3rd Floorl,Xingtianhaiyuan Building,Xianghuangqi East Rd,Nongda South Rd, Haidian District,Beijing,P.R.C
				Bei Jing    100193
				CN

20-CE-2A   (hex)		Ariston Thermo s.p.a.
C00000-CFFFFF     (base 16)		Ariston Thermo s.p.a.
				Via Aristide Merloni 45
				Fabriano  Ancona  60044
				IT

20-CE-2A   (hex)		Jabil
200000-2FFFFF     (base 16)		Jabil
				10560 Dr M.L.K. Jr St N, St.
				St. Petersburg    33716
				US

88-C9-B3   (hex)		ADOPT NETTECH PVT LTD
000000-0FFFFF     (base 16)		ADOPT NETTECH PVT LTD
				A - 11, OKHLA INDUSTRIAL AREA, PHASE - I, 
				NEW DELHI  DELHI  110020
				IN

7C-CB-E2   (hex)		Aplex Technology Inc.
E00000-EFFFFF     (base 16)		Aplex Technology Inc.
				501-5B01,Xintianxia phase 2 building,Wankecheng community,Bantian township,Longgang district
				Shenzhen City  Guangdong  518129
				CN

88-C9-B3   (hex)		Gefran Drive & Motion srl
A00000-AFFFFF     (base 16)		Gefran Drive & Motion srl
				Via Carducci 24
				Gerenzano (VA)  Varese  21040
				IT

C8-F5-D6   (hex)		Jabil
600000-6FFFFF     (base 16)		Jabil
				10560 Dr M.L.K. Jr St N, St.
				St. Petersburg    33716
				US

C8-F5-D6   (hex)		Volansys technologies pvt ltd
D00000-DFFFFF     (base 16)		Volansys technologies pvt ltd
				Block A-7th Floor, Safal Profitaire, Corporate Road, Prahaladnagar
				Ahmedabad  Gujarat  380015
				IN

C0-FB-F9   (hex)		HAGUENET
500000-5FFFFF     (base 16)		HAGUENET
				 Nieuwe Parklaan 17
				The Hague    2597 LA
				NL

C0-FB-F9   (hex)		LIXIL Corporation
100000-1FFFFF     (base 16)		LIXIL Corporation
				2-1-1 Ojima, Koto-ku
				Tokyo  Select Stat  136-8535
				JP

C0-FB-F9   (hex)		SHENZHEN COMIX HST CLOUD COMPUTING CO., LTD.
B00000-BFFFFF     (base 16)		SHENZHEN COMIX HST CLOUD COMPUTING CO., LTD.
				1408? Qiancheng Commercial Center, No. 5 Haicheng Road, Mabu Community, Xixiang Sub-district, Bao'an District
				Shenzhen  Guangdong  518000
				CN

C0-FB-F9   (hex)		SHENZHEN HEQIANG ELECTRONICS LIMITED
300000-3FFFFF     (base 16)		SHENZHEN HEQIANG ELECTRONICS LIMITED
				ROOM F7, 6TH FLOOR, A1 BUILDING, RED BOX LOFT, NO. 3 SOUTH HUANCHENG ROAD, LONGGANG DISTRICT,
				SHENZHEN  GUANGDONG  518129
				CN

D0-9F-D9   (hex)		Carbon Mobile GmbH
500000-5FFFFF     (base 16)		Carbon Mobile GmbH
				Winterfeldtstr. 21
				Berlin    10781
				DE

D0-9F-D9   (hex)		ENTTEC Pty Ltd.
900000-9FFFFF     (base 16)		ENTTEC Pty Ltd.
				po box 4051
				ringwood  vic  3134
				AU

D0-9F-D9   (hex)		elecgator bvba
100000-1FFFFF     (base 16)		elecgator bvba
				Heerbaan, 308
				Beringen  Limburg  3582
				BE

D0-9F-D9   (hex)		Minibems Ltd
E00000-EFFFFF     (base 16)		Minibems Ltd
				Oxford Point, 19 Oxford Road
				Bournemouth    BH88GS
				GB

30-49-50   (hex)		Merlyn Mind, Inc.
D00000-DFFFFF     (base 16)		Merlyn Mind, Inc.
				405 Lexington Avenue, Suite 3504
				New York  NY  10174
				US

18-74-E2   (hex)		G&O Audio Co.,LTD
E00000-EFFFFF     (base 16)		G&O Audio Co.,LTD
				3005, No.15-3, Haitian Road, Building C, N23 Excellence Times Square, Haiwang Community, Xin 'an Street, Bao 'an District
				Shenzhen    518000
				CN

E8-78-29   (hex)		Tanz Security Technology Ltd.
000000-0FFFFF     (base 16)		Tanz Security Technology Ltd.
				11F., No. 203 Zhonghua 1st. road, Gushan District
				Kaohsiung    80455
				TW

E8-78-29   (hex)		Electronic Controlled Systems, Inc.
300000-3FFFFF     (base 16)		Electronic Controlled Systems, Inc.
				11200 Hampshire Ave South
				Bloomington  MN  55438
				US

E8-78-29   (hex)		AXING AG
600000-6FFFFF     (base 16)		AXING AG
				Gewerbehaus Moskau
				Ramsen    8262
				CH

78-13-05   (hex)		Jiangxi Winsky Intelligence Technology Co., Ltd
400000-4FFFFF     (base 16)		Jiangxi Winsky Intelligence Technology Co., Ltd
				Zhihang road Wutong Ave. Hight tech area Jingdezhen City Jiangxi province PRC.
				Jingdezhen   Jiangxi  333000
				CN

78-13-05   (hex)		Global Media Streaming LLC
100000-1FFFFF     (base 16)		Global Media Streaming LLC
				251 Little Falls Drive
				Wilmington  DE  19808
				US

78-13-05   (hex)		ATS-CONVERS,LLC
500000-5FFFFF     (base 16)		ATS-CONVERS,LLC
				Yana Fabrittsyusa str. 10
				Pskov    180017
				RU

78-13-05   (hex)		Leonardo SpA - Montevarchi 
A00000-AFFFFF     (base 16)		Leonardo SpA - Montevarchi 
				via DELLA LAMA, 13
				Montevarchi  AREZZO  52025
				IT

78-13-05   (hex)		InnoSenT
000000-0FFFFF     (base 16)		InnoSenT
				Am Roedertor 30  
				Donnersdorf  Bavaria  97499
				DE

A8-5B-36   (hex)		ShangHai SnowLake Technology Co.,LTD.
800000-8FFFFF     (base 16)		ShangHai SnowLake Technology Co.,LTD.
				30/F?Building#4,Si Chuang B?dg,No. 600Tianshan Rd, Changning District ,Shanghai
				SHANGHAI  SHANGHAI  200050
				CN

A8-5B-36   (hex)		Lampyris Plant LLC
B00000-BFFFFF     (base 16)		Lampyris Plant LLC
				st.Arbuzova, 12, office. 201
				Novosibirsk    630117
				RU

F0-2A-2B   (hex)		Shanghai Armour Technology Co., Ltd.
200000-2FFFFF     (base 16)		Shanghai Armour Technology Co., Ltd.
				Room 411, building 10, 471 Guiping Road, Xuhui District
				Shanghai  Shanghai  200233
				CN

F0-2A-2B   (hex)		EL.MO. spa
B00000-BFFFFF     (base 16)		EL.MO. spa
				Via Pontarola, 70
				Campodarsego  Padua  I35011
				IT

F0-2A-2B   (hex)		Agile Sports Technologies, dba Hudl
500000-5FFFFF     (base 16)		Agile Sports Technologies, dba Hudl
				600 P St, Suite 400
				Lincoln  NE  68508
				US

F0-2A-2B   (hex)		Onclave Networks
400000-4FFFFF     (base 16)		Onclave Networks
				7950  Jones Branch Drive  #805
				McLean  VA  22102
				US

F0-2A-2B   (hex)		Navigil Ltd
A00000-AFFFFF     (base 16)		Navigil Ltd
				Karaportti 5
				Espoo  Uusimaa  02610
				FI

F0-2A-2B   (hex)		Definitely Win Corp.,Ltd.
D00000-DFFFFF     (base 16)		Definitely Win Corp.,Ltd.
				2F., No. 48, Da'an St., Xizhi Dist.,
				New Taipei City  Taiwan (R.O.C.)  221041
				TW

F0-2A-2B   (hex)		Merlin Security Inc.
000000-0FFFFF     (base 16)		Merlin Security Inc.
				 11836 Clark St
				Arcadia  CA  91006
				US

44-A9-2C   (hex)		Shenzhen Lianfaxun Electronic Technology Co.,Ltd
500000-5FFFFF     (base 16)		Shenzhen Lianfaxun Electronic Technology Co.,Ltd
				No. 25, Tianrong road, Tianliao second industrial park, Yutang street, Guangming new district
				Shenzhen  Guangdong   518132
				CN

44-A9-2C   (hex)		Digiport OU
A00000-AFFFFF     (base 16)		Digiport OU
				Sepapaja 6
				Tallinn  Tallinn  15551
				EE

44-A9-2C   (hex)		Cubitech
C00000-CFFFFF     (base 16)		Cubitech
				4-6 Kiprou str
				Tavros  Athens  17778
				GR

58-48-49   (hex)		Shenzhen Tongye Technology Co.,Ltd
900000-9FFFFF     (base 16)		Shenzhen Tongye Technology Co.,Ltd
				Meitai Industry Zone, Guanguang Road, Guihua zone, Guanlan street, Longhua District, Shenzhen
				Shenzhen    518000
				CN

44-A9-2C   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

44-A9-2C   (hex)		Luxonis Holding Corporation
300000-3FFFFF     (base 16)		Luxonis Holding Corporation
				7901 Shaffer Parkway
				Littleton  CO  80127
				US

58-48-49   (hex)		Hubei Shudi Communication Technology Co., Ltd
500000-5FFFFF     (base 16)		Hubei Shudi Communication Technology Co., Ltd
				11 Lane 2, shuichan street, Huangmei County
				Huanggang  Hubei  435500
				CN

58-48-49   (hex)		Viper Design LLC
300000-3FFFFF     (base 16)		Viper Design LLC
				154 Cude Ln
				Madison  TN  37115
				US

64-33-B5   (hex)		Hometek Eletronics Co., Ltd
A00000-AFFFFF     (base 16)		Hometek Eletronics Co., Ltd
				7F-2 No. 16,Lane 609, Section 5 Chung Hsin Rd. Sanchong District. New Taipei City Taiwan R.O.C.
				New Taipei City  Taiwan  241
				TW

58-48-49   (hex)		Avadesign Technology Co. Ltd.
E00000-EFFFFF     (base 16)		Avadesign Technology Co. Ltd.
				4F.-10, No.351, Sec. 2, Zhongshan Rd., Zhonghe Dist.
				New Taipei City    23504
				TW

58-48-49   (hex)		Beijing Zhongyuanyishang Technology Co Ltd
000000-0FFFFF     (base 16)		Beijing Zhongyuanyishang Technology Co Ltd
				Unit 404, 4th Floor, Building 12, Yard 69, Fushi Road, Haidian District, Beijing
				Beijing    100000
				CN

58-48-49   (hex)		SKAARHOJ ApS
100000-1FFFFF     (base 16)		SKAARHOJ ApS
				Rosenkaeret 11C
				Soeborg    2860
				DK

64-33-B5   (hex)		Wingtech Mobile Communications Co.,Ltd
300000-3FFFFF     (base 16)		Wingtech Mobile Communications Co.,Ltd
				No.777,Yazhong Road,Nanhu District
				Jiaxing  Zhejiang  314001
				CN

64-33-B5   (hex)		Huaqin Telecom Technology Co.,Ltd.
100000-1FFFFF     (base 16)		Huaqin Telecom Technology Co.,Ltd.
				Building 1,No.399, Keyuan Road, Pudong, Shanghai China
				Shanghai    200120
				CN

28-36-13   (hex)		Linear Computing Inc.
300000-3FFFFF     (base 16)		Linear Computing Inc.
				110 Galaxy Blvd
				Etobicoke  Ontario  M9W 4Y6
				CA

64-33-B5   (hex)		IIYAMA CORPORATION
D00000-DFFFFF     (base 16)		IIYAMA CORPORATION
				Wijkermeerstraat 8
				Hoofddorp    2131HA
				NL

28-36-13   (hex)		Hi-p (Suzhou) Electronics Co,Ltd
100000-1FFFFF     (base 16)		Hi-p (Suzhou) Electronics Co,Ltd
				5th floor, building G, no. 2337 gudai road (weijing center)
				Shanghai  minhang district  215128
				CN

78-5E-E8   (hex)		Yake (Tianjin) Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Yake (Tianjin) Technology Co.,Ltd.
				No.2, Zhengtong Road, Caozili Town, Wuqing District, Tianjin
				Tianjin  Tianjin  301727
				CN

78-5E-E8   (hex)		Lantern Engineering (Pty) Ltd
B00000-BFFFFF     (base 16)		Lantern Engineering (Pty) Ltd
				Unit 101 & 101A, Execujet Business Centre, Tower Road
				Cape Town  Western Cape  7490
				ZA

78-5E-E8   (hex)		MT B?LG? TEKNOLOJ?LER? VE DI? T?C. A.?.
700000-7FFFFF     (base 16)		MT B?LG? TEKNOLOJ?LER? VE DI? T?C. A.?.
				Tekstilkent Ticaret Merkezi Koza Plaza B Blok K:26 At??alan? 
				?STANBUL  ESENLER  34235
				TR

78-5E-E8   (hex)		INFOMOBILITY S.R.L.
500000-5FFFFF     (base 16)		INFOMOBILITY S.R.L.
				Via per Vallalta, S.P.7
				Concordia sulla Secchia  Modena  41033
				IT

78-5E-E8   (hex)		Youtransactor
000000-0FFFFF     (base 16)		Youtransactor
				32 Rue Brancion
				Paris    75015
				FR

A0-22-4E   (hex)		TMGcore, Inc.
400000-4FFFFF     (base 16)		TMGcore, Inc.
				6815 Communications Parkway
				Plano  TX  75024
				US

38-A8-CD   (hex)		Dongguan Fyrnetics Co., Ltd
300000-3FFFFF     (base 16)		Dongguan Fyrnetics Co., Ltd
				No.1 Rongwen Road, Dongguan Changan, Guangdong, China 523842
				Dongguan  Guangdong  523842
				CN

38-A8-CD   (hex)		WHITEvoid GmbH
400000-4FFFFF     (base 16)		WHITEvoid GmbH
				Köpenicker Chaussee 4
				Berlin  Berlin  10317
				DE

7C-83-34   (hex)		Thermalimage
000000-0FFFFF     (base 16)		Thermalimage
				Unit 4 Airside, Boeing Avenue, Waterford Airport Business Park
				Waterford  Munster  X91RTA4
				IE

1C-AE-3E   (hex)		Netvio Ltd
500000-5FFFFF     (base 16)		Netvio Ltd
				InfoLab21, Lancaster University, Bailrigg Road
				Lancaster  Lancastershire  LA14WA
				GB

1C-AE-3E   (hex)		LINKWISE TECHNOLOGIES CO., LIMITED
200000-2FFFFF     (base 16)		LINKWISE TECHNOLOGIES CO., LIMITED
				LINKWISE TECHNOLOGIES CO., LIMITED
				Shanghai  Shanghai  200072
				CN

1C-AE-3E   (hex)		JingQi(tianjin) technology Co., Ltd
800000-8FFFFF     (base 16)		JingQi(tianjin) technology Co., Ltd
				Building E88, No.1 Sizhidao Rd., Xiqing University Industrial Zone
				Tianjin    300382
				CN

1C-AE-3E   (hex)		IPROAD,Inc
100000-1FFFFF     (base 16)		IPROAD,Inc
				407 ENC Dreamtower VI, 41 digital-ro 31gil, gurogu
				Seoul    08375
				KR

1C-AE-3E   (hex)		Beijing Boyan-rd Technology Development CO.,LTD
B00000-BFFFFF     (base 16)		Beijing Boyan-rd Technology Development CO.,LTD
				Room 1514, 15 / F, building a 1, Qinghe Jiayuan East District
				Beijing  Haidian District  100085
				CN

98-6E-E8   (hex)		Shanghai Pixsur Smart Technology Co.,Ltd
100000-1FFFFF     (base 16)		Shanghai Pixsur Smart Technology Co.,Ltd
				Room 1204, No.1223, Xietu Road,Xuhui District
				Shanghai  Shanghai  201100
				CN

1C-AE-3E   (hex)		Broachlink Technology Co.,Limited
E00000-EFFFFF     (base 16)		Broachlink Technology Co.,Limited
				1212, Yongtong BLDG,RenMin North Rd.,
				Shenzhen  GuangDong  518100
				CN

98-6E-E8   (hex)		Private
B00000-BFFFFF     (base 16)		Private

98-6E-E8   (hex)		Ugreen Group Limited
200000-2FFFFF     (base 16)		Ugreen Group Limited
				4F, Plant 6, 1F-6/F, Block 7, YuAn Zone, Gaofeng Community, Dalang Street, Longhua District
				Shenzhen  Guangdong  518109
				CN

98-80-BB   (hex)		Guangzhou Shortcut Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Guangzhou Shortcut Technology Co.,Ltd.
				Building No.7 Guangbao Road, Huangpu District
				Guangzhou  Guangdong  510700
				CN

98-80-BB   (hex)		Jyh Eng Technology Co., Ltd
800000-8FFFFF     (base 16)		Jyh Eng Technology Co., Ltd
				5F, No. 50, Lane 1 , Sec.2, Guodao Rd., 
				Lujhou Dist.,   New Taipei City,   247020
				TW

98-80-BB   (hex)		Shanghai ECone Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Shanghai ECone Technology Co.,Ltd.
				Room1418,Floor5Building9,YangmingRoad,Xinghu,Development Zone, Fengxian,District,Shanghai
				Shanghai    200000
				CN

98-80-BB   (hex)		Melexis Technologies NV
500000-5FFFFF     (base 16)		Melexis Technologies NV
				Transportstraat 1
				Tessenderlo  Select State  3980
				BE

78-72-64   (hex)		Shenzhen C-DIGI Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Shenzhen C-DIGI Technology Co.,Ltd.
				MeishengChuanggu(Xiagu), No. 10 Longchang Rd., Xin'an, Bao'an,
				Shenzhen    518000
				CN

58-FC-DB   (hex)		Prometheus Security Group Global, Inc.
700000-7FFFFF     (base 16)		Prometheus Security Group Global, Inc.
				3019 Alvin Devane Boulevard  Building 4, Suite 400
				Austin  TX  78741
				US

F4-70-0C   (hex)		Shenzhen Lidaxun Digital Technology Co., LTD
500000-5FFFFF     (base 16)		Shenzhen Lidaxun Digital Technology Co., LTD
				Room 7A, Building A3, HuaFengShiJiKeJiYuan, GuShu Street, BaoAn District
				Shenzhen  Guangdong  518100
				CN

F4-A4-54   (hex)		Advanced Mechanical Technology, Inc. d/b/a AMTI
700000-7FFFFF     (base 16)		Advanced Mechanical Technology, Inc. d/b/a AMTI
				176 Waltham Street
				Watertown  MA  02472
				US

F4-A4-54   (hex)		Integrated Dynamics Engineering GmbH
C00000-CFFFFF     (base 16)		Integrated Dynamics Engineering GmbH
				Hermannstrasse 9 - 13
				Raunheim  Hessen  65479
				DE

F4-A4-54   (hex)		Lonton infomation tech Ltd., Co
900000-9FFFFF     (base 16)		Lonton infomation tech Ltd., Co
				L15 Block 5C, Huaqiang idea Park, Guangming District
				Shenzhen  Guangdong  518000
				CN

18-45-B3   (hex)		Bdf Digital
C00000-CFFFFF     (base 16)		Bdf Digital
				Via dell'Oreficeria 41
				Vicenza  Italy  36100
				IT

18-45-B3   (hex)		Guangzhou Aoshi Internet Information & Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Guangzhou Aoshi Internet Information & Technology Co.,Ltd.
				Room 401-410,A Building ,23# Nanxiang Road, Huangpu District
				Guangzhou  Guangdong  510663
				CN

18-45-B3   (hex)		Harmonic Technology Limited
600000-6FFFFF     (base 16)		Harmonic Technology Limited
				Building B, No. 8 Tianxin Street, Yongkou Management District, Management District, Shijie Town
				Dongguan  Guangdong  523290
				CN

18-45-B3   (hex)		Mission Secure Inc
400000-4FFFFF     (base 16)		Mission Secure Inc
				100 10th St NE STE 301
				Charlottesville  VA  22902
				US

08-F8-0D   (hex)		FG-Lab Inc.
400000-4FFFFF     (base 16)		FG-Lab Inc.
				KDX shibadaimon.Bld 2F 2-10-12 Shibadaimon
				Minato-ku  Tokyo  1050012
				JP

94-C9-B7   (hex)		Fairy Devices Inc.
000000-0FFFFF     (base 16)		Fairy Devices Inc.
				Yushima Urban Bldg 7F, 2-31-22 Yushima Bunkyo-ku
				Tokyo    113-0034
				JP

94-C9-B7   (hex)		ShenZhen Beide Technology Co.,LTD
A00000-AFFFFF     (base 16)		ShenZhen Beide Technology Co.,LTD
				SHENZHEN BEIDE Technology Co,.LTD ???3 / F, Building A, Tengfei Industrial Building, No.6 taohua Road, Fubao Community, Fubao Street, Futian District, Shenzhen   
				ShenZhen  GuangDong  518000
				CN

94-C9-B7   (hex)		Private
900000-9FFFFF     (base 16)		Private

94-C9-B7   (hex)		shenzhen UDD Technologies,co.,Ltd
E00000-EFFFFF     (base 16)		shenzhen UDD Technologies,co.,Ltd
				Unit D, 6th Floor, Jialitai Bldg., No.45 Yanshan Road, Shekou, Nanshan District, Shenzhen, China
				shenzhen  guangdong  51800
				CN

94-C9-B7   (hex)		Beijing Anyunshiji Technology Co., Ltd.
500000-5FFFFF     (base 16)		Beijing Anyunshiji Technology Co., Ltd.
				1002, 10F, Room 102, Floor 1-17, Building 2, Yard 6, Jiuxianqiao Road, Chaoyang District
				Beijing    100015
				CN

94-C9-B7   (hex)		3D Biomedicine Science & Technology Co., Limited
B00000-BFFFFF     (base 16)		3D Biomedicine Science & Technology Co., Limited
				Building 2, Block A, 158 XinJunhuan Street, Pujiang Hi-tech Park
				Shanghai  Shanghai  201114
				CN

50-A0-30   (hex)		Abacus Research AG
600000-6FFFFF     (base 16)		Abacus Research AG
				Abacus-Platz 1
				Wittenbach  St. Gallen  9300
				CH

50-A0-30   (hex)		Alert Innovation
400000-4FFFFF     (base 16)		Alert Innovation
				101 Billerica Ave Bldg 3
				North Billerica  MA  01862
				US

50-A0-30   (hex)		DPA Microphones A/S
900000-9FFFFF     (base 16)		DPA Microphones A/S
				Gydevang 42-44
				Alleroed    3450
				DK

04-EE-E8   (hex)		Hengke Technology Industry Co., Ltd.
200000-2FFFFF     (base 16)		Hengke Technology Industry Co., Ltd.
				No.305-1 Torch Road, High District, WeiHai
				WeiHai  ShanDong  264200
				CN

50-A0-30   (hex)		Annapurna labs
200000-2FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

04-EE-E8   (hex)		Shenzhen Daotong Technology Co.,Ltd
400000-4FFFFF     (base 16)		Shenzhen Daotong Technology Co.,Ltd
				7th, 8th, 10th Floor, Building B1, Zhiyuan Road, No. 1001 Xueyuan Avenue, Xili Street, Nanshan District, Shenzhen
				SHENZHEN    518000
				CN

04-EE-E8   (hex)		RealWear
500000-5FFFFF     (base 16)		RealWear
				600 Hathaway Rd, Ste 105
				Vancouver  WA  98661
				US

04-EE-E8   (hex)		Fluid Management Technology
300000-3FFFFF     (base 16)		Fluid Management Technology
				169 Grange Rd, Beverley
				169 Grange Rd, Beverley, South Australia 5009 AU.  South Australia  5009
				AU

18-D7-93   (hex)		EcoG
B00000-BFFFFF     (base 16)		EcoG
				Gaenslerweg 24
				Furth  Bavaria  82041
				DE

18-D7-93   (hex)		Teegarden Applied Science Inc
E00000-EFFFFF     (base 16)		Teegarden Applied Science Inc
				2510 rue de l'Aeroport
				St-Mathieu-de-Beloeil  Quebec  J3G0C9
				CA

DC-36-43   (hex)		Meier Tobler AG
000000-0FFFFF     (base 16)		Meier Tobler AG
				Bahnstrasse 24
				Schwerzenbach  ZH  8603
				CH

DC-36-43   (hex)		nami.ai
B00000-BFFFFF     (base 16)		nami.ai
				3 Temasek Avenue, #17-19
				Singapore    039190
				SG

DC-36-43   (hex)		WIS Networks
300000-3FFFFF     (base 16)		WIS Networks
				702, No. 60,  langbaoxi  Road, Chancheng District
				foshan  guangdong  528000
				CN

DC-36-43   (hex)		Dongguan Pengchen Earth Instrument CO. LT
100000-1FFFFF     (base 16)		Dongguan Pengchen Earth Instrument CO. LT
				Room 301, Building 1, No.6, North Huwu Road, Liuwu Village, Shijie Town, Dongguan city, Guangdong Province
				Dongguan    523290
				CN

DC-36-43   (hex)		Hangzhou Huanyu Vision Technology Co., Ltd
D00000-DFFFFF     (base 16)		Hangzhou Huanyu Vision Technology Co., Ltd
				 Room 701, block n, No. 88, China (Hangzhou) smart information industrial park, Gongshu District,
				Hangzhou  Zhejiang  310011
				CN

08-26-AE   (hex)		BANGJOO Co., Ltd.
400000-4FFFFF     (base 16)		BANGJOO Co., Ltd.
				745-34, Samnam-ro,Jinwi-myeon
				Pyeongtaek  Gyeonggi-do  17718
				KR

08-26-AE   (hex)		Brannstrom Sweden AB
C00000-CFFFFF     (base 16)		Brannstrom Sweden AB
				Uddevallagatan 14
				Göteborg    41670
				SE

08-26-AE   (hex)		Newcapec co.,Ltd
600000-6FFFFF     (base 16)		Newcapec co.,Ltd
				18 Yingchun Street, High-tech Development Zone
				Zhengzhou  Henan  450000
				CN

98-8F-E0   (hex)		Changzhou Perceptime Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Changzhou Perceptime Technology Co.,Ltd.
				5/f, biological building, 1326 Yanan West road, Changning District
				Shanghai  Shanghai  200052
				CN

98-8F-E0   (hex)		Huaqin Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Huaqin Technology Co.,Ltd.
				10 Keyuan Road, Songshan Lake
				Dongguan    Guangdong  523419
				CN

98-8F-E0   (hex)		Schmid AG, energy solutions
400000-4FFFFF     (base 16)		Schmid AG, energy solutions
				Hörnlistrasse 12
				Eschlikon    8360
				CH

98-8F-E0   (hex)		Pavana Technologies JSC.
A00000-AFFFFF     (base 16)		Pavana Technologies JSC.
				Lot F1-2-3, Thang Long Vinh Phuc IP., Tam Hop Commune, Binh Xuyen District
				Vinh Phuc    35000
				VN

10-54-D2   (hex)		GIPS Technology Co., Ltd.
000000-0FFFFF     (base 16)		GIPS Technology Co., Ltd.
				Rm. 2, 6F., No. 395, Sec. 1, Linsen Rd., East Dist.
				 Tainan City  TAIWAN  701024
				TW

10-54-D2   (hex)		Embion B.V.
A00000-AFFFFF     (base 16)		Embion B.V.
				Biestraat 1b
				Gilze  Noord-Brabant  5126NH
				NL

10-54-D2   (hex)		Little Array Technology (Shenzhen) Co., Ltd.
300000-3FFFFF     (base 16)		Little Array Technology (Shenzhen) Co., Ltd.
				Unit 215, 2F, A1, Zhimei Industry Park, Fuhai Industrial Zone B2, Fuyong Street, Baoan District
				Shenzhen  Guangdong  518103
				CN

10-54-D2   (hex)		LUXSHARE-ICT Co., Ltd.
C00000-CFFFFF     (base 16)		LUXSHARE-ICT Co., Ltd.
				1F, No. 22, Lane 35, Jihu Road, Neihu district
				Taipei City  Taiwan  114754
				TW

10-54-D2   (hex)		COSMO AIOT TECHNOLOGY CO LTD
E00000-EFFFFF     (base 16)		COSMO AIOT TECHNOLOGY CO LTD
				Haier Information Industrial Complex, No.1 HaierRoad
				Qingdao  Shandong  266101
				CN

0C-86-29   (hex)		SHENZHEN YINGMU TECHNOLOGY.,LTD
C00000-CFFFFF     (base 16)		SHENZHEN YINGMU TECHNOLOGY.,LTD
				8 / F, Zone D, building F1, TCL International E city, Shuguang community, Xili street, Nanshan District,
				Shenzhen    518000
				CN

0C-86-29   (hex)		Nipron Co.,Ltd
A00000-AFFFFF     (base 16)		Nipron Co.,Ltd
				1-3-30 Nishinagasucho
				Amagasaki-shi  Hyogo-ken  660-0805
				JP

0C-86-29   (hex)		FX TECHNOLOGY LIMITED
E00000-EFFFFF     (base 16)		FX TECHNOLOGY LIMITED
				38a High Street, Northwood
				Middlesex  -  HA6 1BN
				GB

6C-93-08   (hex)		LightnTec GmbH
300000-3FFFFF     (base 16)		LightnTec GmbH
				Haid-und-Neu-Strasse 7
				Karlsruhe    76131
				DE

30-43-D7   (hex)		Shenzhen juduoping Technology Co.,Ltd
100000-1FFFFF     (base 16)		Shenzhen juduoping Technology Co.,Ltd
				Baoan Xin'an Streat
				Shenzhen    002052
				CN

30-43-D7   (hex)		Sprocomm Technologies Co., Ltd.Guangming Branch
600000-6FFFFF     (base 16)		Sprocomm Technologies Co., Ltd.Guangming Branch
				Area A 3rd Floor, Area A 5rd Floor and 6th Floor, 301, building 2, 7th Industrial Park, Yulv Community,Yutang Street, Guangming District, 
				Shenzhen    518000
				CN

6C-93-08   (hex)		Shenzhen haichangxing Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Shenzhen haichangxing Technology Co., Ltd.
				Room 3102, 31 / F, Wen an Center, Wenjin Square, Luohu
				SHENZHEN  GUANGZHOU  518000
				CN

30-43-D7   (hex)		Guangdong Hongqin Telecom  Technology Co. Ltd.
E00000-EFFFFF     (base 16)		Guangdong Hongqin Telecom  Technology Co. Ltd.
				10 Keyuan Road, Songshan Lake
				Dongguan  Guangdong   523808
				CN

38-1F-26   (hex)		Bosch Automotive Electronics India Pvt. Ltd.
300000-3FFFFF     (base 16)		Bosch Automotive Electronics India Pvt. Ltd.
				Naganathapura
				Bengaluru  Karnataka  560100
				IN

18-A5-9C   (hex)		Erba Lachema s.r.o.
A00000-AFFFFF     (base 16)		Erba Lachema s.r.o.
				Karasek1d
				Brno    62100
				CZ

18-A5-9C   (hex)		ePower Network Solution Co., Ltd.
700000-7FFFFF     (base 16)		ePower Network Solution Co., Ltd.
				No. 2, Aly. 1, Ln. 85, Xinshu Rd., Xinzhuang Dist., 
				New Taipei City ,    242063
				TW

1C-59-74   (hex)		Shenzhen Hanshine Technology Co.Ltd.
000000-0FFFFF     (base 16)		Shenzhen Hanshine Technology Co.Ltd.
				Buiding 2 ,row 3,number 2 industrail  zone,yulv community,Yutang street 
				Shenzhen  Guangdong  518000
				CN

1C-59-74   (hex)		Chongqing Taishan Cable Co., Ltd
200000-2FFFFF     (base 16)		Chongqing Taishan Cable Co., Ltd
				17 Shiyan Avenue, Yufengshan Town, Yubei District,
				Chongqing    400000
				CN

18-A5-9C   (hex)		Beijing QS Medical Technology Co., Ltd.
300000-3FFFFF     (base 16)		Beijing QS Medical Technology Co., Ltd.
				Building 5, No.11, Kechuang 14th Street, Economic-Technological Development Area
				Beijing    100176
				CN

C4-A1-0E   (hex)		Clinton Electronics Corporation
B00000-BFFFFF     (base 16)		Clinton Electronics Corporation
				6701 Clinton Road
				Loves Park  IL  61111
				US

C4-A1-0E   (hex)		Wistron InfoComn (Kunshan) Co., Ltd.
200000-2FFFFF     (base 16)		Wistron InfoComn (Kunshan) Co., Ltd.
				No.88 Hongyan Road, Kunshan Economic & Technological Development Zone
				Kunshan  Jiangsu  215300
				CN

6C-15-24   (hex)		Telsonic AG
100000-1FFFFF     (base 16)		Telsonic AG
				Industriestrasse 6b
				Bronschhofen  St.Gallen  9552
				CH

C4-A1-0E   (hex)		Guangzhou South Satellite Navigation Instrument Co., Ltd.
700000-7FFFFF     (base 16)		Guangzhou South Satellite Navigation Instrument Co., Ltd.
				Area A Layer 6, Area A Layer 5, Area A Layer 4, No.39, Sicheng Road, Tianhe District,
				Guangzhou  GuangDong  510663
				CN

6C-15-24   (hex)		Motium Pty Ltd
700000-7FFFFF     (base 16)		Motium Pty Ltd
				11/4 Brodie Hall Drive,
				Bentley  Western Australia  6102
				AU

6C-15-24   (hex)		SYMLINK CORPORATION
D00000-DFFFFF     (base 16)		SYMLINK CORPORATION
				6F., No. 13, Lane. 35, Jihu Rd., Neihu Dist., Neihu Technology Park
				Taipei    11492
				TW

6C-15-24   (hex)		AEC s.r.l.
E00000-EFFFFF     (base 16)		AEC s.r.l.
				Via Zambon, 33/A
				Creazzo  Vicenza  36051
				IT

C4-A1-0E   (hex)		Harbour Cross Technology Ltd
400000-4FFFFF     (base 16)		Harbour Cross Technology Ltd
				Unit 622 One Island South, 2 Heung Yip Road, Wong Chuk Hang,
				Hong Kong  China  000000
				HK

70-50-E7   (hex)		Annapurna labs
100000-1FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

70-50-E7   (hex)		Shenzhen C & D Electronics Co., Ltd.
000000-0FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

70-50-E7   (hex)		Beijing Shannoncyber Technology Co.,Ltd
B00000-BFFFFF     (base 16)		Beijing Shannoncyber Technology Co.,Ltd
				913 9/F,building 8,yard 2,Shenggu Middle Road,Chaoyang District
				beijing  beijing  100029
				CN

80-02-F4   (hex)		PassiveLogic
A00000-AFFFFF     (base 16)		PassiveLogic
				6405 S 3000 E, Suite 300
				Holladay  UT  84121
				US

80-02-F4   (hex)		XUNDI(XIAMEN) ELECTRONIC TECHNOLOGY CO.,LTD.
900000-9FFFFF     (base 16)		XUNDI(XIAMEN) ELECTRONIC TECHNOLOGY CO.,LTD.
				SECOND  FLOOR, NO. 943-4, TONGLONG 2ND ROAD, TORCH HIGH-TECH (XIANG 'AN) INDUSTRY DISTRICT,XIAMEN CITY, FUJIAN PROVINCE,CHINA
				XIAMEN    361106
				CN

80-02-F4   (hex)		Sichuan Fanyi Technology Co. Ltd.
500000-5FFFFF     (base 16)		Sichuan Fanyi Technology Co. Ltd.
				No. 1707, Unit 1, Building 1, 888, Middle Section of Yizhou Avenue, Gaoxin District
				Chengdu  Sichuan  650000
				CN

80-02-F4   (hex)		Jiangsu Vedkang Medicl Sclence and Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Jiangsu Vedkang Medicl Sclence and Technology Co.,Ltd
				No. 52, Guoxiang Road, Wujin economic development zone
				ChangZhou  JiangSu  213100
				CN

80-02-F4   (hex)		Infors AG
400000-4FFFFF     (base 16)		Infors AG
				Wuhrmattstr. 7
				Bottmingen    4103
				CH

80-02-F4   (hex)		Mech-Mind Robotics Technologies Ltd.
600000-6FFFFF     (base 16)		Mech-Mind Robotics Technologies Ltd.
				 Room 1001,1F,Building 3, No.8,Chuangye Road,Haidian District
				Beijing    100085
				CN

8C-51-09   (hex)		ENPLUG Co., Ltd.
700000-7FFFFF     (base 16)		ENPLUG Co., Ltd.
				#A-705, 46 Dallaenae-ro, Sujeong-gu, 
				Seongnam-si  Gyeonggi-do  13449
				KR

8C-51-09   (hex)		Frontmatec
900000-9FFFFF     (base 16)		Frontmatec
				Hassellunden 9
				Smørum    2765
				DK

0C-7F-ED   (hex)		ShenZhen TianGang Micro Technology CO.LTD
500000-5FFFFF     (base 16)		ShenZhen TianGang Micro Technology CO.LTD
				3rd floor ,Building20,QingHu Industrial,QingHu community,LongHua DistrictShenZhen,China
				ShenZhen  GangDong  518100
				CN

0C-7F-ED   (hex)		U-tec Group Inc.
800000-8FFFFF     (base 16)		U-tec Group Inc.
				32920 Alvarado-Niles Rd Ste 220
				Union City  CA  94587
				US

0C-7F-ED   (hex)		Soft dB
300000-3FFFFF     (base 16)		Soft dB
				1040, avenue Belvédère #215
				Québec  Quebec  G1S 3G3
				CA

FC-61-79   (hex)		MACH SYSTEMS s.r.o.
900000-9FFFFF     (base 16)		MACH SYSTEMS s.r.o.
				Pocernicka 272/96
				Prague    10800
				CZ

FC-61-79   (hex)		Annapurna labs
800000-8FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

FC-61-79   (hex)		Zhuhai Anjubao Electronics Technology Co., Ltd.
000000-0FFFFF     (base 16)		Zhuhai Anjubao Electronics Technology Co., Ltd.
				Room 603, Building 4, No. 101, Daxue Road, Tangjiawan Town, High-tech Zone,
				Zhuhai  Guangdong  519000
				CN

FC-61-79   (hex)		Shenzhen Shenshui Electronic Commerce Co.,Ltd
200000-2FFFFF     (base 16)		Shenzhen Shenshui Electronic Commerce Co.,Ltd
				Room 517, Biaofan Building, No. 6, Tangwei Industrial Avenue, Fuhai Street, Baoan District
				Shenzhen    518132
				CN

4C-4B-F9   (hex)		Shandong Linkotech Electronic Co., Ltd.
600000-6FFFFF     (base 16)		Shandong Linkotech Electronic Co., Ltd.
				22nd Floor, Building 2, Aosheng Building, No.1166 Xinyi Street, High-tech Zone
				Jinan  Shandong  250101
				CN

4C-4B-F9   (hex)		Power Active Co., Ltd
300000-3FFFFF     (base 16)		Power Active Co., Ltd
				4F, No.23, Wugong 6th Rd., Wugu Dist.
				New Taipei City    248
				TW

4C-4B-F9   (hex)		Multitek Elektronik Sanayi ve Ticaret A.S.
000000-0FFFFF     (base 16)		Multitek Elektronik Sanayi ve Ticaret A.S.
				Meclis Mah. Ataturk Cad. No:47, sancaktepe
				istanbul    34785
				TR

20-85-93   (hex)		Mid Continent Controls, Inc.
200000-2FFFFF     (base 16)		Mid Continent Controls, Inc.
				901 North River Street
				Derby  KS  67037
				US

34-04-9E   (hex)		Connected IO
100000-1FFFFF     (base 16)		Connected IO
				573 University Ave
				Los Gatos  CA  95032
				US

24-15-10   (hex)		Topgolf Sweden AB
900000-9FFFFF     (base 16)		Topgolf Sweden AB
				Svärdvägen 11
				Danderyd  Stockholm  182 33
				SE

24-15-10   (hex)		SuZhou A-rack Information Technology Co.,Ltd
700000-7FFFFF     (base 16)		SuZhou A-rack Information Technology Co.,Ltd
				No.10 Xinting Road,Suzhou New District
				Suzhou  Jiangsu  215000
				CN

20-85-93   (hex)		AASSET SECURITY
800000-8FFFFF     (base 16)		AASSET SECURITY
				153 RUE MICHEL CARRE
				ARGENTEUIL    95100
				FR

20-85-93   (hex)		Wave-In Communication
500000-5FFFFF     (base 16)		Wave-In Communication
				8F, No.322, Sec. 1, Neihu Rd., Neihu Dist.
				Taipei City    114
				TW

BC-66-41   (hex)		Private
F00000-FFFFFF     (base 16)		Private

98-06-37   (hex)		Angora Networks
A00000-AFFFFF     (base 16)		Angora Networks
				Alacaatli Mah. Park Cad 47/31, Cayyolu
				Ankara    06810
				TR

64-FB-81   (hex)		Private
F00000-FFFFFF     (base 16)		Private

78-C2-C0   (hex)		Private
F00000-FFFFFF     (base 16)		Private

14-1F-BA   (hex)		Private
F00000-FFFFFF     (base 16)		Private

58-FC-DB   (hex)		Private
F00000-FFFFFF     (base 16)		Private

74-F8-DB   (hex)		Private
F00000-FFFFFF     (base 16)		Private

7C-70-BC   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D0-76-50   (hex)		Private
F00000-FFFFFF     (base 16)		Private

44-D5-F2   (hex)		Shenzhen Hebang Electronic Co., Ltd
200000-2FFFFF     (base 16)		Shenzhen Hebang Electronic Co., Ltd
				2nd Floor West, Bldg B, Kelunte Low Carbon Industry Park, Huarong Road, Dalang, Longhua District
				Shenzhen    518000
				CN

98-06-37   (hex)		Chengdu Shuwei Communication Technology Co.,Ltd
400000-4FFFFF     (base 16)		Chengdu Shuwei Communication Technology Co.,Ltd
				The Second floor, G4 Building, G zone, Tianfu Software Park, 1800 Yizhou Avenue, High Tech Dsitrict
				Chengdu  Sichuan  610041
				CN

D0-5F-64   (hex)		Nanjing Huamai Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Nanjing Huamai Technology Co.,Ltd
				No.11 Runfa Road, Dongshan Industry Gathering Zone, Jiangning District
				Nanjing  Jiangsu  210000
				CN

44-D5-F2   (hex)		Valeo Interior Controls (Shenzhen) Co.,Ltd
B00000-BFFFFF     (base 16)		Valeo Interior Controls (Shenzhen) Co.,Ltd
				North Junyi Ind. Park, Huaide Vil., Fuyong Town, Baoan Dist.
				Shenzhen  Guangzhong  518103
				CN

44-D5-F2   (hex)		tiga.eleven GmbH
500000-5FFFFF     (base 16)		tiga.eleven GmbH
				Stallburggasse 2/37
				Viennna    1010
				AT

D0-5F-64   (hex)		PartnerNET LTD
A00000-AFFFFF     (base 16)		PartnerNET LTD
				Salaminos 5
				Nicossia  Strovolos  2044
				CY

FC-A4-7A   (hex)		Hefei Feier Smart Science&Technology Co. Ltd
E00000-EFFFFF     (base 16)		Hefei Feier Smart Science&Technology Co. Ltd
				6 / F 1#ZhongShi Building,CSV, High-tech Zone
				HEFEI    230000
				CN

FC-A4-7A   (hex)		HOOC AG
400000-4FFFFF     (base 16)		HOOC AG
				Torweg 8
				Visp  VS  3930
				CH

2C-16-BD   (hex)		Beijing Zhijian Link Technology Co., Ltd.
500000-5FFFFF     (base 16)		Beijing Zhijian Link Technology Co., Ltd.
				C3-1358, 3rd floor, No. 18 North Taipingzhuang Road, Haidian District
				Beijing  Beijing  100088
				CN

FC-A4-7A   (hex)		Syfer
500000-5FFFFF     (base 16)		Syfer
				227 SANDY SPRINGS PL SUITE D-454
				Atlanta  GA  30328-5918
				US

FC-A4-7A   (hex)		Ant Financial（Hang Zhou）Network Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Ant Financial（Hang Zhou）Network Technology Co.,Ltd.
				801-10,8th Floor B Section,556Xixi Road,XihuDistrict,
				HangzhouCity  ZhejiangProvince  310007
				CN

2C-16-BD   (hex)		Molex Incorporated 
E00000-EFFFFF     (base 16)		Molex Incorporated 
				46360 Fremont Blvd
				Fremont  CA  94538
				US

D0-5F-64   (hex)		wallbe GmbH
400000-4FFFFF     (base 16)		wallbe GmbH
				Paderborner Straße 76
				Schlangen   NRW  33189
				DE

D0-5F-64   (hex)		Decathlon SA
000000-0FFFFF     (base 16)		Decathlon SA
				4 Boulevard de Mons
				Villeneuve d'Ascq  Haut de France  59650
				FR

B4-A2-EB   (hex)		 DCI International, LLC.
100000-1FFFFF     (base 16)		 DCI International, LLC.
				305 N Springbrook Road
				Newberg  OR  97132
				US

B4-A2-EB   (hex)		ShenZhen Lark Acoustics Co., Ltd. 
600000-6FFFFF     (base 16)		ShenZhen Lark Acoustics Co., Ltd. 
				Room 2406, Northwestern Polytechnical University, Gaoxin South Nine Road,Nanshan District
				Shenzhen  Guangdong  518000
				CN

2C-16-BD   (hex)		Hangzhou Yanzhi Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Hangzhou Yanzhi Technology Co.,Ltd.
				Room 406, 4th floor, building 6,316 jianghong south road,Binjiang Dist
				Hangzhou  Zhejiang  310030
				CN

B4-A2-EB   (hex)		Dongguan Finslink Communication Technology Co.,Ltd.
E00000-EFFFFF     (base 16)		Dongguan Finslink Communication Technology Co.,Ltd.
				Room 202,2nd floor,G3 Building, University Innovation City,Songshan Lake High-tech Industrial Development Zone
				Dongguan  Guangdong  523808
				CN

8C-59-3C   (hex)		Dantherm Cooling Inc.
C00000-CFFFFF     (base 16)		Dantherm Cooling Inc.
				110 Corporate Dr., Suite K
				Spartanburg  SC  29303
				US

B4-A2-EB   (hex)		Canaan Creative Co.,Ltd.
300000-3FFFFF     (base 16)		Canaan Creative Co.,Ltd.
				ZPark 27# QianFang Science Building C,  Haidian District, Beijing, China.
				Beijing  Beijing  100094
				CN

2C-16-BD   (hex)		CLOUDWALK TECHNOLOGY CO.,LTD
600000-6FFFFF     (base 16)		CLOUDWALK TECHNOLOGY CO.,LTD
				Five Floors of Block 106, West Jinkai Avenue, Yubei District
				Chongqing  Chongqing  401120
				CN

D0-C8-57   (hex)		Imin Technology Pte Ltd
400000-4FFFFF     (base 16)		Imin Technology Pte Ltd
				77 Sciene park Drive #03-10 Cintech III 
				Singapore  Singapore  118256
				SG

74-5B-C5   (hex)		Beijing Inspiry Technology Co., Ltd. 
100000-1FFFFF     (base 16)		Beijing Inspiry Technology Co., Ltd. 
				Building No. 5, East Zone, No. 10, Xibeiwang East Road, Haidian District
				Beijing  Beijing  100092
				CN

D0-C8-57   (hex)		shenzhen cnsun
A00000-AFFFFF     (base 16)		shenzhen cnsun
				5 Floor, 2 Building,Tongfuyu Industrial City
				shenzhen  guangdong  518000
				CN

D0-C8-57   (hex)		Shenzhen xiaosha  Intelligence  Technology Co. Ltd
900000-9FFFFF     (base 16)		Shenzhen xiaosha  Intelligence  Technology Co. Ltd
				 Poly Building, 2702 Nanhai Avenue, Nanshan District
				Shenzhen  Guangdong  518054
				CN

D0-C8-57   (hex)		Innovative Industrial(HK)Co., Limited
600000-6FFFFF     (base 16)		Innovative Industrial(HK)Co., Limited
				OFFICE 3A,12/F,KAISER CENTRE,NO.18CENTRE STREET
				SAI YING PUN    999077
				HK

30-0A-60   (hex)		Beijing Ruiteng Zhongtian TECH Ltd.,Co
100000-1FFFFF     (base 16)		Beijing Ruiteng Zhongtian TECH Ltd.,Co
				Blk 6,Rm 602,Noble CenterⅡ，No.1 Automotive Museum East Lane,South Fourth Ring Road, Fengtai District
				Beijing  Beijing  100070
				CN

BC-97-40   (hex)		Lattec I/S
200000-2FFFFF     (base 16)		Lattec I/S
				Blytækkervej 10
				Hillerød    3400
				DK

A4-3B-FA   (hex)		Private
F00000-FFFFFF     (base 16)		Private

D0-C8-57   (hex)		FORGAMERS INC.
200000-2FFFFF     (base 16)		FORGAMERS INC.
				6F., NO.51, DONGXING RD., XINYI DIST., TAIPEI CITY 110-70, TAIWAN
				Taipei    110
				TW

60-95-CE   (hex)		Cadmo Soluciones SAC
700000-7FFFFF     (base 16)		Cadmo Soluciones SAC
				Av. Angamos Este 2495 Dpt. 301, San Borja
				Lima  Lima  15036
				PE

60-95-CE   (hex)		GovComm
D00000-DFFFFF     (base 16)		GovComm
				3830 SW 30 Ave
				Fort Lauderdale  FL  33312
				US

60-95-CE   (hex)		Ponoor Experiments Inc.
100000-1FFFFF     (base 16)		Ponoor Experiments Inc.
				Higashi-shinagawa 1-33-10, Terrada Art Complex 216
				Shinagawa-ku  Tokyo  1400002
				JP

BC-97-40   (hex)		Alpha ESS Co., Ltd.
000000-0FFFFF     (base 16)		Alpha ESS Co., Ltd.
				JiuHua Road 888, Nantong High-Tech Industrial Development Zone,
				Nantong  Jiangsu  226300
				CN

60-95-CE   (hex)		(UN)MANNED
A00000-AFFFFF     (base 16)		(UN)MANNED
				Baron Ruzettelaan 3
				Brugge    8310
				BE

60-95-CE   (hex)		Jlztlink Industry(ShenZhen)Co.,Ltd.
900000-9FFFFF     (base 16)		Jlztlink Industry(ShenZhen)Co.,Ltd.
				D-502#,Tongan logistics center,Sanwei hangkong 30#,Xiang street,Baoan,
				Shenzhen  Guangdong  518000
				CN

60-95-CE   (hex)		Robot S.A.
300000-3FFFFF     (base 16)		Robot S.A.
				Gremi de Cirurgians i Barbers 22
				Palma de Mallorca  SPAIN / Balearic Islands  07009
				ES

BC-97-40   (hex)		Rollock Oy
D00000-DFFFFF     (base 16)		Rollock Oy
				Viestitie 2 B
				Kajaani    87700
				FI

BC-34-00   (hex)		Private
F00000-FFFFFF     (base 16)		Private

1C-82-59   (hex)		Shandong Luneng Intelligence Technology CO., Ltd
000000-0FFFFF     (base 16)		Shandong Luneng Intelligence Technology CO., Ltd
				Shandong Jinan Hightech zone Yinhe building block B, 2008 Xinluo Street
				Jinan  Shandong  250100
				CN

1C-82-59   (hex)		Jump Trading
700000-7FFFFF     (base 16)		Jump Trading
				1 London Wall
				London     EC2Y 5EA
				GB

1C-82-59   (hex)		winsun AG
400000-4FFFFF     (base 16)		winsun AG
				Beeschi Mattenstrasse 2
				Steg  Wallis  3940
				CH

F8-1D-78   (hex)		TELEOFIS
800000-8FFFFF     (base 16)		TELEOFIS
				1K3, Electrolitny proezd
				Moscow    115230
				RU

1C-82-59   (hex)		Applied Concepts, Inc.
D00000-DFFFFF     (base 16)		Applied Concepts, Inc.
				855 E Collins Blvd
				Richardson  TX  75081
				US

84-8B-CD   (hex)		CHONGQING HUAYI KANGDAO TECHNOLOGY CO.,LTD.
B00000-BFFFFF     (base 16)		CHONGQING HUAYI KANGDAO TECHNOLOGY CO.,LTD.
				14th Floor, Unicom Building, 192 Yuzhou Road, Yuzhong District
				CHONGQING    410010
				CN

84-8B-CD   (hex)		NORALSY
900000-9FFFFF     (base 16)		NORALSY
				16 rue Lavoisier
				Chennevieres sur Marne  Ile de France  94430
				FR

1C-82-59   (hex)		Evondos Oy
C00000-CFFFFF     (base 16)		Evondos Oy
				Salorankatu 5-7
				Salo    24240
				FI

1C-82-59   (hex)		Fagus-GreCon Greten GmbH & Co. KG
500000-5FFFFF     (base 16)		Fagus-GreCon Greten GmbH & Co. KG
				Hannoversche Straße 58
				Alfeld    31061
				DE

1C-82-59   (hex)		C&A Marketing, INC.
300000-3FFFFF     (base 16)		C&A Marketing, INC.
				114 Tived Lane East
				Edison   NJ  08837
				US

B0-FD-0B   (hex)		MartinLogan, Ltd.
B00000-BFFFFF     (base 16)		MartinLogan, Ltd.
				2101 Delware St
				Lawrence  KS  66046
				US

B0-FD-0B   (hex)		DNESO TEN Ltd.
600000-6FFFFF     (base 16)		DNESO TEN Ltd.
				1-2-28,gosho-doori,hyougo-ku
				kobe  hyougo  652-8510
				JP

84-8B-CD   (hex)		Shenzhen LTIME In-Vehicle Entertainment System Company Limited
100000-1FFFFF     (base 16)		Shenzhen LTIME In-Vehicle Entertainment System Company Limited
				4/F, Building 1, Nangang 1st Industrial Park No. 1029, Songbai Road, Xili, Nanshan District
				SHENZHEN  GUANGDONG  518055
				CN

B0-FD-0B   (hex)		Haltian Products Oy
C00000-CFFFFF     (base 16)		Haltian Products Oy
				Yrttipellontie 1D
				Oulu    90230
				FI

80-7B-85   (hex)		Private
F00000-FFFFFF     (base 16)		Private

E4-1E-0A   (hex)		IDvaco Private Limited
200000-2FFFFF     (base 16)		IDvaco Private Limited
				Aljunied road, 627A,06-02
				singapore  singapore  389842
				SG

E4-1E-0A   (hex)		Connected Cars A/S
100000-1FFFFF     (base 16)		Connected Cars A/S
				Park Allé 355
				Brøndby    2605
				DK

E4-1E-0A   (hex)		B METERS S.R.L.
900000-9FFFFF     (base 16)		B METERS S.R.L.
				VIA FRIULI 3
				GONARS  UDINE  33050
				IT

E4-1E-0A   (hex)		Safety Vision, LLC
B00000-BFFFFF     (base 16)		Safety Vision, LLC
				6100 West Sam Houston Parkway North
				Houston  TX  77041-5113
				US

E4-1E-0A   (hex)		XPR Group
400000-4FFFFF     (base 16)		XPR Group
				Drève Richelle 161 - WOP G
				Waterloo    1410
				BE

E4-1E-0A   (hex)		SFC Energy AG
600000-6FFFFF     (base 16)		SFC Energy AG
				Eugen-Saenger-Ring 7
				Brunnthal    85649
				DE

C8-63-14   (hex)		Shenzhen Lihewei Electronics Co.,Ltd.Hunan Branch
B00000-BFFFFF     (base 16)		Shenzhen Lihewei Electronics Co.,Ltd.Hunan Branch
				Room 501,Room 502,Building 2,Xinggong Technology Park,No.100 Luyun Road, High-tech Development Zone
				Changsha  Hunan  410000
				CN

34-E1-D1   (hex)		Hubitat Inc.
800000-8FFFFF     (base 16)		Hubitat Inc.
				20343 N Hayden Rd, Suite 105-280
				Scottsdale  AZ  85255
				US

34-E1-D1   (hex)		APG Cash Drawer, LLC
B00000-BFFFFF     (base 16)		APG Cash Drawer, LLC
				5250 Industrial Blvd NE
				Minneapolis  MN  55421
				US

34-E1-D1   (hex)		OrCam Technologies
A00000-AFFFFF     (base 16)		OrCam Technologies
				Kiryat Hamada 3
				JERUSALEM    97775603
				IL

FC-D2-B6   (hex)		Cirque Audio Technology Co.,Ltd
600000-6FFFFF     (base 16)		Cirque Audio Technology Co.,Ltd
				No.2 Road BeiYiHeng,HuangJiaBao Industrial Park,ShiPai Town,DongGuan City,GuangDong,China
				DongGuan  GuangDong  523000
				CN

FC-D2-B6   (hex)		LINK (FAR-EAST) CORPORATION
100000-1FFFFF     (base 16)		LINK (FAR-EAST) CORPORATION
				No.192, Lian-Cheng Rd., Chung-Ho, Taipei,Taiwan 23553
				Taipei  Taiwan  23553
				TW

FC-D2-B6   (hex)		SHEN ZHEN XIN HAO YUAN PRECISION TECHNOLOGY CO.,L TD
400000-4FFFFF     (base 16)		SHEN ZHEN XIN HAO YUAN PRECISION TECHNOLOGY CO.,L TD
				1,2,3 Building,XinHaoYuan Industrial Area,HeYi Community,Shajing Street,BaoAn District.Shenzhen
				shenzhen  guangdongsheng  518000
				CN

FC-D2-B6   (hex)		Teamly Digital
700000-7FFFFF     (base 16)		Teamly Digital
				11-13 Avenue de Friedland
				Paris  Ile de France  75008
				FR

74-5B-C5   (hex)		Qingdao Wintec System Co., Ltd
E00000-EFFFFF     (base 16)		Qingdao Wintec System Co., Ltd
				Wintec Park, Xinye Road, High-tech Zone, Qingdao, China 266114
				QING DAO  shan dong  of  China  6805
				CN

74-5B-C5   (hex)		SIGLENT TECHNOLOGIES CO., LTD.
200000-2FFFFF     (base 16)		SIGLENT TECHNOLOGIES CO., LTD.
				Blog No.4 & No.5, Antongda Industrial Zone, 3rd Liuxian Road, Bao’an District, Shenzhen, 518101, China.
				Shenzhen  Guangdong  518101
				CN

74-5B-C5   (hex)		Yekani Manufacturing PTY Ltd
600000-6FFFFF     (base 16)		Yekani Manufacturing PTY Ltd
				Fourways Golf Park,Selbourne Building,Roos St
				Witkoppen  Gauteng  5214
				ZA

74-5B-C5   (hex)		SHENZHEN ATX TECHNOLOGY CO.,LTD 
700000-7FFFFF     (base 16)		SHENZHEN ATX TECHNOLOGY CO.,LTD 
				7/F,Zhengjiyuan Buiding,2 Road,Qianjing, Xixiang, Baoan District
				Shenzhen  GUANGDONG  518000
				CN

E4-4C-C7   (hex)		Ottomate International Pvt. Ltd.
900000-9FFFFF     (base 16)		Ottomate International Pvt. Ltd.
				Awfis Building, 5th Floor, Plot # 7, Sector-44
				Gurgaon  Haryana  122003
				IN

E4-4C-C7   (hex)		ACS-Solutions GmbH
100000-1FFFFF     (base 16)		ACS-Solutions GmbH
				Science Park 2
				Saarbrücken    66123
				DE

E4-4C-C7   (hex)		Telo Systems Limitd
D00000-DFFFFF     (base 16)		Telo Systems Limitd
				4/F, Chuangye Building, Seven-Star Park, Yu'an 2nd Road
				ShenZhen  GuangDong  518000
				CN

E4-4C-C7   (hex)		SmallHD
B00000-BFFFFF     (base 16)		SmallHD
				301 Gregson Dr
				Cary  NC  27511
				US

74-5B-C5   (hex)		SpringCard
500000-5FFFFF     (base 16)		SpringCard
				2 voie La Cardon, Parc Gutenberg
				PALAISEAU  IDF  91120
				FR

74-5B-C5   (hex)		IRS Systementwicklung GmbH
000000-0FFFFF     (base 16)		IRS Systementwicklung GmbH
				Pfaffenthanner Weg, 5
				Brennberg    93179
				DE

28-FD-80   (hex)		Private
F00000-FFFFFF     (base 16)		Private

E0-5A-9F   (hex)		ShenZhen Mornsun Smartlinker Limited Co., LTD
C00000-CFFFFF     (base 16)		ShenZhen Mornsun Smartlinker Limited Co., LTD
				South 2nd Flr, 23 Bldg, Yuanxi Industrial Zone, Kefa Rd, Nanshan Keji Yuan
				ShenZhen  GuangDong  518058
				CN

4C-BC-98   (hex)		Elink Technology (Shenzhen) Co., Limited
D00000-DFFFFF     (base 16)		Elink Technology (Shenzhen) Co., Limited
				C-323,Baoan,Xinyidai Info.Tech.Industrial Park, No.139 Chuangye Er Rd.,Baoan District
				Shenzhen  Guangdong  518101
				CN

4C-BC-98   (hex)		Charge-Amps AB
000000-0FFFFF     (base 16)		Charge-Amps AB
				GUSTAV III:S BOULEVARD 42, 8TR
				SOLNA    16973
				SE

38-B1-9E   (hex)		ShenZhen ShuaiXian Electronic Equipment Co.Ltd
E00000-EFFFFF     (base 16)		ShenZhen ShuaiXian Electronic Equipment Co.Ltd
				No. 10, Lane 3, Longxing Rd, Dakang Village,HengGang Town
				ShenZhen  Guangdong  518115
				CN

D8-86-0B   (hex)		Auvidea GmbH
300000-3FFFFF     (base 16)		Auvidea GmbH
				Kellerberg 3
				Denklingen    86920
				DE

28-F5-37   (hex)		1MORE
800000-8FFFFF     (base 16)		1MORE
				TianliaoBuilding F14
				New Materials Industrial Park,Xueyuan Blvd  Shenzhen, Nanshan District  518005
				CN

D8-86-0B   (hex)		 YUSAN INDUSTRIES LIMITED  
C00000-CFFFFF     (base 16)		 YUSAN INDUSTRIES LIMITED  
				UNIT 8-9, 8/F., HONOUR INDUSTRIAL CENTRE, 6 SUN YIP STREET, CHAI WAN
				HongKong    999077
				HK

D8-86-0B   (hex)		Library Ideas
B00000-BFFFFF     (base 16)		Library Ideas
				PO Box 9
				Vienna  VA  22183
				US

D8-86-0B   (hex)		ComNav Technology Ltd.
D00000-DFFFFF     (base 16)		ComNav Technology Ltd.
				Buliding 2,No. 618  Chengliu Middle  Road
				JiaDing District  Shanghai  201801
				CN

38-B1-9E   (hex)		Star Electronics GmbH & CoKG
500000-5FFFFF     (base 16)		Star Electronics GmbH & CoKG
				Jahnstraße, 86
				Göppingen    73037
				DE

38-B1-9E   (hex)		HDANYWHERE
200000-2FFFFF     (base 16)		HDANYWHERE
				Unit 23 Link Business Centre
				Malvern  Worcs  WR14 1UQ
				GB

38-B1-9E   (hex)		Aeroespacial Guosheng Technology Co., Ltd
A00000-AFFFFF     (base 16)		Aeroespacial Guosheng Technology Co., Ltd
				501 Edificio Gaode, No. 10 Huayuan East Road,
				Haiden DIstrict  Beijing  100191
				CN

D8-86-0B   (hex)		Shenzhen Yidong Technology Co.,Ltd
E00000-EFFFFF     (base 16)		Shenzhen Yidong Technology Co.,Ltd
				13th Floor,Jia'anda Building, No.110 Huafan Road,Tongsheng Community, Dalang Street,Longhua District
				Shenzhen  Guangdong  518000
				CN

D8-86-0B   (hex)		VRINDA NANO TECHNOLOGIES PVT LTD
800000-8FFFFF     (base 16)		VRINDA NANO TECHNOLOGIES PVT LTD
				PLOT NO.283, SECTOR 7, IMT MANESAR, GURGAON 
				INDIA  HARYANA  122050
				IN

38-B1-9E   (hex)		Triple Jump Medical
000000-0FFFFF     (base 16)		Triple Jump Medical
				5 HaCarmel St.
				Yokneam    2069203
				IL

38-B1-9E   (hex)		BoCo Inc.
800000-8FFFFF     (base 16)		BoCo Inc.
				Isshin Bldg 6F,Yaesu 2-11-7
				Chuo-ku, Tokyo    104-0028
				JP

38-B1-9E   (hex)		Gesellschaft industrieller Technologien 
C00000-CFFFFF     (base 16)		Gesellschaft industrieller Technologien 
				Hauptstraße 10
				Großbeeren    14979 
				DE

CC-D3-9D   (hex)		Q-Branch Labs, Inc.
B00000-BFFFFF     (base 16)		Q-Branch Labs, Inc.
				427 N. Tatnall St., Suite #82712
				Wilmington  DE  19801
				US

CC-D3-9D   (hex)		Shenzhen Chenggu Technology Co., Ltd
400000-4FFFFF     (base 16)		Shenzhen Chenggu Technology Co., Ltd
				Longgang District Jihua street Zhonghaixin Industrial Innovation City 19A 3F
				Shenzhen  Guagndong  518112
				CN

CC-D3-9D   (hex)		Krontech
600000-6FFFFF     (base 16)		Krontech
				I.T.U ARI 3 Teknokent Kron Telekomunikasyon, Maslak
				Istanbul    34467
				TR

CC-D3-9D   (hex)		Bejing Nexsec Inc.
900000-9FFFFF     (base 16)		Bejing Nexsec Inc.
				Floor 5, Room 5001,Buliding No.4,Fengxian Middle Road No.7
				(Beike Industrial Park),Haidian District,  Beijing  100094
				CN

CC-D3-9D   (hex)		Obelisk Inc.
800000-8FFFFF     (base 16)		Obelisk Inc.
				67 Batterymarch Street, Floor 4
				Boston    02110
				US

D4-25-CC   (hex)		TAKUMI JAPAN LTD
900000-9FFFFF     (base 16)		TAKUMI JAPAN LTD
				3-9-3 Uchiyama building 7F Nishishinbashi
				Minato-ku Tokyo  Tokyo  1050003
				JP

9C-69-B4   (hex)		NINGBO SHEN LINK COMMUNICATION TECHNOLOGY CO., LTD
E00000-EFFFFF     (base 16)		NINGBO SHEN LINK COMMUNICATION TECHNOLOGY CO., LTD
				NO.87,FENGMINGROAD,LIZHOUSTREET, YUYAO, ZHEJIANG
				NINGBO  ZHEJIANG  315400
				CN

4C-91-7A   (hex)		Openeye
600000-6FFFFF     (base 16)		Openeye
				23221 East Knox Avenue
				Liberty Lake  WA  99019
				US

4C-91-7A   (hex)		Smart Access
300000-3FFFFF     (base 16)		Smart Access
				Nauchnuy Proezd 10
				Moscow    117246
				RU

9C-69-B4   (hex)		Suzhou Fitcan Technology Co.,LTD
000000-0FFFFF     (base 16)		Suzhou Fitcan Technology Co.,LTD
				Kechuang Road
				Suzhou City  Jiangsu Province  215163
				CN

9C-69-B4   (hex)		Guangdong Hanwei intergration Co.,Ltd
C00000-CFFFFF     (base 16)		Guangdong Hanwei intergration Co.,Ltd
				Room 404,7# Hongtai Zhihui Gu, No.23 Sicheng Road
				Guangzhou  Guangdong  510663
				CN

9C-69-B4   (hex)		Shenzhen jiahua zhongli technology co.LTD
600000-6FFFFF     (base 16)		Shenzhen jiahua zhongli technology co.LTD
				3/F,building B,JINHU building,industrial road,longhua new district
				Shenzhen  Guangdong  518109
				CN

6C-DF-FB   (hex)		Nanjing Buruike Electronics Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Nanjing Buruike Electronics Technology Co., Ltd.
				Jiangning District Moling Street, SuYuan Avenue No.117 Building 2, Floor 5 Room 541
				Nanjing  Jiangsu  210000
				CN

4C-91-7A   (hex)		Alibaba (Beijing) Software Service Inc.
C00000-CFFFFF     (base 16)		Alibaba (Beijing) Software Service Inc.
				No. 301, 3 floor, 9 building, four district, Wangjing East Garden, Chaoyang District,
				Beijing  Beijing  100102
				CN

4C-91-7A   (hex)		mtekvision
500000-5FFFFF     (base 16)		mtekvision
				6F, C's Tower, 58, Pangyo-ro 255veon-gil, Bundang-gu
				seongnam-si  Gyeonggi-do  13486
				KR

7C-BC-84   (hex)		Beijing Topnew Group Co., Ltd
E00000-EFFFFF     (base 16)		Beijing Topnew Group Co., Ltd
				No.9, A, Jin Tai Li, ChaoYang District 
				Beijing    100026
				CN

7C-BC-84   (hex)		Shenzhen Kuang-chi  Space Technology Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen Kuang-chi  Space Technology Co., Ltd.
				No. 1 building, No. 2 Reservoir Road, Nan Keng community , Bantian street, Longgang District, Shenzhen
				shenzhen  Guangdong  518000
				CN

6C-DF-FB   (hex)		Lineable Inc
400000-4FFFFF     (base 16)		Lineable Inc
				5, Ttukseom-ro 1na-gil, Seongdong-gu, Seoul, Republic of Korea, Heyground, G505
				Seoul  Seoul  04779
				KR

98-F9-C7   (hex)		NC-LINK Technology Co., Ltd.
E00000-EFFFFF     (base 16)		NC-LINK Technology Co., Ltd.
				Block A2 Jinhai Business Mansion, Jinhai Road, Xixiang town
				Shenzhen  Guangdong  518101
				CN

7C-BC-84   (hex)		Shanghai Yitu Technology Co. Ltd
300000-3FFFFF     (base 16)		Shanghai Yitu Technology Co. Ltd
				23/F, Tower 1, No.523 Loushanguan Road, Changning District
				Shanghai    200051
				CN

0C-FE-5D   (hex)		Antailiye Technology Co.,Ltd
600000-6FFFFF     (base 16)		Antailiye Technology Co.,Ltd
				7/F,Zhengjiyuan Buiding,2 Road,Qianjing, Xixiang, Baoan District,Shenzhen
				SHEN ZHEN  GUANGDONG  518000
				CN

0C-FE-5D   (hex)		Yantai Dongfang Wisdom Electic Co.,Ltd.
400000-4FFFFF     (base 16)		Yantai Dongfang Wisdom Electic Co.,Ltd.
				6 Jindu Road
				Yantai  Shandong  264003
				CN

98-F9-C7   (hex)		Pozyx NV
200000-2FFFFF     (base 16)		Pozyx NV
				Vrijdagmarkt 10/201
				Gent  Oost-Vlaanderen  9000
				BE

0C-FE-5D   (hex)		SELECTRIC Nachrichten-Systeme GmbH
500000-5FFFFF     (base 16)		SELECTRIC Nachrichten-Systeme GmbH
				Haferlandweg 18
				Münster    48155
				DE

0C-FE-5D   (hex)		Vermes Microdispensing GmbH
700000-7FFFFF     (base 16)		Vermes Microdispensing GmbH
				Palnkamer Strasse 18
				Otterfing  Bayern  83624
				DE

10-07-23   (hex)		Private
F00000-FFFFFF     (base 16)		Private

6C-5C-3D   (hex)		IskraUralTEL
900000-9FFFFF     (base 16)		IskraUralTEL
				Komvuzovkaya
				Ekaterinburg    620137
				RU

6C-5C-3D   (hex)		HTI Co., LTD.
400000-4FFFFF     (base 16)		HTI Co., LTD.
				Rm741, Kyungin Ctr., 20, Baekbeom-ro 577, Bupyung-Gu
				Incheon    21449
				KR

A8-3F-A1   (hex)		Plejd AB
700000-7FFFFF     (base 16)		Plejd AB
				Göteborgsvägen 52
				Mölndal    431 37
				SE

A8-3F-A1   (hex)		Guangzhou Navigateworx Technologies Co., Limited
E00000-EFFFFF     (base 16)		Guangzhou Navigateworx Technologies Co., Limited
				Room 2320, Qianjin Commercial Building, Dongpu Town
				Guangzhou  Guangdong  510660
				CN

A8-3F-A1   (hex)		Shanghai East China Computer Co., Ltd
A00000-AFFFFF     (base 16)		Shanghai East China Computer Co., Ltd
				27/F Tower B, No.391 Guiping Rd
				Shanghai  Shanghai  200233
				CN

A0-3E-6B   (hex)		Private
F00000-FFFFFF     (base 16)		Private

A8-3F-A1   (hex)		Laonz Co.,Ltd
C00000-CFFFFF     (base 16)		Laonz Co.,Ltd
				15-3,Eonnam-Gil,Seocho-gu
				Seoul    06779
				KR

3C-6A-2C   (hex)		figur8, Inc.
300000-3FFFFF     (base 16)		figur8, Inc.
				2 Park Plaza, Suite 605
				BOSTON  MA  02116
				US

30-0A-60   (hex)		Realtime biometrics India pvt ltd
600000-6FFFFF     (base 16)		Realtime biometrics India pvt ltd
				C-68,1st Floor ganesh nagar pandav nagar complex
				delhi  Delhi  110092
				IN

A4-ED-43   (hex)		Shanghai  Facom  Electronics Technology  Co, ltd.
600000-6FFFFF     (base 16)		Shanghai  Facom  Electronics Technology  Co, ltd.
				The third floor, A area,         Huaxu road No. 685
				Shanghai  Xujing town，Qingpu  200217
				CN

30-0A-60   (hex)		Advanced Electronic Designs, Inc.
200000-2FFFFF     (base 16)		Advanced Electronic Designs, Inc.
				233 Enterprise Blvd
				Bozeman  MT  59718
				US

A0-28-33   (hex)		SHANGHAI XUNTAI INFORMATION TECHNOLOGY CO.,LTD.
300000-3FFFFF     (base 16)		SHANGHAI XUNTAI INFORMATION TECHNOLOGY CO.,LTD.
				ET SPACE, ZIZHU PARK, NO.555, DONGCHUAN RD.
				SHANGHAI  SHANGHAI  200241
				CN

A0-28-33   (hex)		Ordercube GmbH
100000-1FFFFF     (base 16)		Ordercube GmbH
				Aßlinger Str. 6
				Grafing b. München  Bayern  85567
				DE

A0-28-33   (hex)		Medical Evolution Kft
A00000-AFFFFF     (base 16)		Medical Evolution Kft
				Liszenko telep 1
				Pomaz    2013
				HU

A0-28-33   (hex)		HZHY TECHNOLOGY
800000-8FFFFF     (base 16)		HZHY TECHNOLOGY
				The 2th floor,Longzeyuan Multi-use
				beijing    102208
				CN

A4-ED-43   (hex)		Beijing ICPC CO.,Ltd.
500000-5FFFFF     (base 16)		Beijing ICPC CO.,Ltd.
				Fengtai District HuaXiang LiuQuan  West Road NO.8 Xinhua ShuangChuangYuan Building B Floor 2 NO.203
				Beijing  Beijing  100070
				CN

A4-ED-43   (hex)		NETAS TELEKOMUNIKASYON A.S.
400000-4FFFFF     (base 16)		NETAS TELEKOMUNIKASYON A.S.
				Kurtköy Mahallesi, Osmanlı Blv. No:11
				Pendik  Istanbul  34912
				TR

A4-ED-43   (hex)		Guangzhou Maxfaith Communication Technology Co.,LTD.
A00000-AFFFFF     (base 16)		Guangzhou Maxfaith Communication Technology Co.,LTD.
				3rd Floor,Office of Youtong Zone,No.139,Zhongshan Avenue
				Guangzhou    510665
				CN

84-89-EC   (hex)		Price Industries Limited
D00000-DFFFFF     (base 16)		Price Industries Limited
				638 Raleigh Street
				Winnipeg  Manitoba  R2K3Z9
				CA

30-09-F9   (hex)		ZhongLi HengFeng (Shenzhen) Technology co.,Ltd.
E00000-EFFFFF     (base 16)		ZhongLi HengFeng (Shenzhen) Technology co.,Ltd.
				Room 402C Donglian Buiding,Chuangye NO 2 road,Baoan
				Shenzhen  Guangdong  430000
				CN

30-09-F9   (hex)		Sichuan Nebula Networks Co.,LTD.
B00000-BFFFFF     (base 16)		Sichuan Nebula Networks Co.,LTD.
				Floor 21 Building 2,No.200 Tianquan Road,West Hi-Tech Zone,
				Chengdu  Sichuan  611731
				CN

84-89-EC   (hex)		thousand star tech LTD.
200000-2FFFFF     (base 16)		thousand star tech LTD.
				guan nan yuan 1 road dangdai optical valley dream workshop
				wuhan  hubei  430070
				CN

9C-F6-DD   (hex)		Shanxi ZhuoZhi fei High Electronic Technology Co. Ltd.
E00000-EFFFFF     (base 16)		Shanxi ZhuoZhi fei High Electronic Technology Co. Ltd.
				Red flag East Street
				yuncheng  shanxi  044000
				CN

B8-D8-12   (hex)		IPM Sales and service Co.,Ltd.
200000-2FFFFF     (base 16)		IPM Sales and service Co.,Ltd.
				250-252 Soi 29 Somdet Prachaotaksin Road
				Bangkok  Bangkok  10600
				TH

9C-F6-DD   (hex)		Beijing Sifang Automation Co., Ltd.
200000-2FFFFF     (base 16)		Beijing Sifang Automation Co., Ltd.
				No.9,Shangdi 4th Street,Haidian District
				Beijing    100085
				CN

9C-F6-DD   (hex)		b8ta Inc.
500000-5FFFFF     (base 16)		b8ta Inc.
				164 Townsend St
				San Francisco  CA  94107
				US

9C-F6-DD   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

30-09-F9   (hex)		Honeywell
C00000-CFFFFF     (base 16)		Honeywell
				13350 US Hwy 19 N 
				Clearwater  null  33764
				US

C0-83-59   (hex)		CHONGQING JIUYU SMART TECHNOLOGY CO.LTD.
000000-0FFFFF     (base 16)		CHONGQING JIUYU SMART TECHNOLOGY CO.LTD.
				T2-11-3, No. 2 Jiangbeizui Financial City, Jiangbei District,
				Chongqing  Chongqing  400000
				CN

04-C3-E6   (hex)		Shenzhen Shuotian Information Technology Co., LTD
600000-6FFFFF     (base 16)		Shenzhen Shuotian Information Technology Co., LTD
				Xixiang Street , Bao'an District
				Shenzhen  Guangdong  518000
				CN

04-C3-E6   (hex)		Advanced Digital Technologies, s.r.o.
700000-7FFFFF     (base 16)		Advanced Digital Technologies, s.r.o.
				Purkynova 649/127
				Medlanky  Brno  612 00
				CZ

04-C3-E6   (hex)		 Guangdong New Pulse Electric Co., Ltd.
100000-1FFFFF     (base 16)		 Guangdong New Pulse Electric Co., Ltd.
				No. 38 South Kemu Road
				 Guangzhou City  Tianhe District, Guangdong Province  510520
				CN

3C-42-7E   (hex)		Xiaoniu network technology (Shanghai) Co., Ltd.
E00000-EFFFFF     (base 16)		Xiaoniu network technology (Shanghai) Co., Ltd.
				Room 706, building 3, no.20 east road, jingan district.
				Shang hai    200040
				CN

04-C3-E6   (hex)		SiS Technology
200000-2FFFFF     (base 16)		SiS Technology
				Business Park Varna, building B1, floor 4
				Varna    9000
				BG

3C-42-7E   (hex)		Dongguan Taide Industrial Co.,Ltd.
100000-1FFFFF     (base 16)		Dongguan Taide Industrial Co.,Ltd.
				Taide Industrial Park,Phase 2 Jinfenghuang Industrial District Huangdong,Fenggang Town
				Dongguan City  GuangDong  523696
				CN

D4-7C-44   (hex)		YunDing Network Technology (Beijing) Co., Ltd
200000-2FFFFF     (base 16)		YunDing Network Technology (Beijing) Co., Ltd
				A521,Floor 5, Tencent Space Building No.388, Hui long guan East St. 
				Beijing    100000
				CN

D4-7C-44   (hex)		Suzhou Wan Dian Zhang Network Technology Co., Ltd
900000-9FFFFF     (base 16)		Suzhou Wan Dian Zhang Network Technology Co., Ltd
				No. 209 Zhuyuan Road, High-tech Zone
				Suzhou City  Jiangsu  215010
				CN

B4-4B-D6   (hex)		 Shenzhen Huabai Intelligent Technology Co., Ltd.
A00000-AFFFFF     (base 16)		 Shenzhen Huabai Intelligent Technology Co., Ltd.
				Science Park South District Shenzhen Digital
				Technology Park Building B2 4th Floor Area A  Shenzhen, Guangdong  518000
				CN

3C-42-7E   (hex)		GJS Co., Ltd.
700000-7FFFFF     (base 16)		GJS Co., Ltd.
				305, Qianhai Innovation and Entrepreneur Hub, Bldg. C Qianwan 1st Rd., Nanshan District
				Shenzhen  Guangdong  518000
				CN

3C-42-7E   (hex)		TAITEX CORPORATION
900000-9FFFFF     (base 16)		TAITEX CORPORATION
				1-7-12,WAKATAKE
				ICHINOMIYA-SHI  AICHI-KEN  491-0832
				JP

B4-4B-D6   (hex)		Impakt S.A.
C00000-CFFFFF     (base 16)		Impakt S.A.
				Stanislawa Lema 16
				Mosina  Wielkopolska  62-050
				PL

A0-19-B2   (hex)		Power Diagnostic Service Co., LTD.
300000-3FFFFF     (base 16)		Power Diagnostic Service Co., LTD.
				No.10, Ln.482, Sec.4 Zhonghua Rd.
				Hsinchu City    30094
				TW

CC-D3-1E   (hex)		CUJO LLC
D00000-DFFFFF     (base 16)		CUJO LLC
				2512 Artesia Blvd
				Redondo Beach  CA  90278
				US

A0-19-B2   (hex)		LDA Technologies
C00000-CFFFFF     (base 16)		LDA Technologies
				2680 Matheson Blvd E., Suite 102
				Mississauga  Ontario  L4W2C6
				CA

A0-19-B2   (hex)		Vast Production Services
000000-0FFFFF     (base 16)		Vast Production Services
				307 Robbins Drive
				Troy  MI  48083
				US

74-F8-DB   (hex)		Ballard Technology, Inc,
A00000-AFFFFF     (base 16)		Ballard Technology, Inc,
				11400 Airport Rd
				Everett    98204
				US

2C-48-35   (hex)		DPS Electronics
800000-8FFFFF     (base 16)		DPS Electronics
				317 Gallatin Park Dr #2
				Bozeman  MT  59715
				US

2C-48-35   (hex)		Shanghai Visteon Automotive Electronics System CO. Ltd.
B00000-BFFFFF     (base 16)		Shanghai Visteon Automotive Electronics System CO. Ltd.
				No.1268, East Kangqiao Road, Pudong District,
				ShangHai    201315
				CN

8C-1C-DA   (hex)		Anntec （Beijing） Technology Co.,Ltd.
400000-4FFFFF     (base 16)		Anntec （Beijing） Technology Co.,Ltd.
				F803, Shangdi Third Street, No.9,HaiDian District
				Beijing    100080
				CN

3C-24-F0   (hex)		CASKY eTech Co., Ltd.
500000-5FFFFF     (base 16)		CASKY eTech Co., Ltd.
				10th Floor, Viva Plaza, Yard 29 Suzhou Street, Haidian District,
				Beijing  Beijing  100080
				CN

0C-73-EB   (hex)		Green Fox Electro AS
600000-6FFFFF     (base 16)		Green Fox Electro AS
				Wessels veg 63
				STJORDAL    NO-7502
				NO

8C-1C-DA   (hex)		China Potevio Co., Ltd
A00000-AFFFFF     (base 16)		China Potevio Co., Ltd
				No.6, haidian north second street, haidian district, Beijing
				Beijing  Beijing  100080
				CN

3C-24-F0   (hex)		Travis Holding B.V.
D00000-DFFFFF     (base 16)		Travis Holding B.V.
				Stationsplein 45, A4.002 3013 AK
				Rotterdam    3013AK
				NL

3C-24-F0   (hex)		Abrites Ltd.
100000-1FFFFF     (base 16)		Abrites Ltd.
				147 Cherni Vrah Blvd.
				Sofia  Sofia  1407
				BG

48-0B-B2   (hex)		Solaredge LTD.
500000-5FFFFF     (base 16)		Solaredge LTD.
				Hamada 1
				Herzelia    4673335
				IL

48-0B-B2   (hex)		shanghai Rinlink  Intelligent Technology Co., Ltd.
300000-3FFFFF     (base 16)		shanghai Rinlink  Intelligent Technology Co., Ltd.
				Room1510,ROAD Xiuwen,Minhang District
				shanghai    201100
				CN

88-5F-E8   (hex)		Unicom Global, Inc.
E00000-EFFFFF     (base 16)		Unicom Global, Inc.
				581, Ruiguang Road, Neihu Dist.
				Taipei    11492
				TW

30-1F-9A   (hex)		 FINE TRIUMPH TECHNOLOGY CORP.,LTD.
800000-8FFFFF     (base 16)		 FINE TRIUMPH TECHNOLOGY CORP.,LTD.
				Xixiang
				Shenzhen  Guangdong  518126
				CN

30-1F-9A   (hex)		Beijing Surestar Technology Co. Ltd,
500000-5FFFFF     (base 16)		Beijing Surestar Technology Co. Ltd,
				Room 502, building 1, No. 5 Yongfeng Road, Haidian District
				Beijing    100089
				CN

30-1F-9A   (hex)		ILSAN ELECTRONICS
000000-0FFFFF     (base 16)		ILSAN ELECTRONICS
				433Beon-gil 52,Sasang-ro,Sasang-gu
				Busan    46923
				KR

30-1F-9A   (hex)		Dewesoft d.o.o.
100000-1FFFFF     (base 16)		Dewesoft d.o.o.
				Gabrsko 11a
				Trbovlje    1420
				SI

F0-41-C8   (hex)		SHENZHEN WISEWING INTERNET TECHNOLOGY CO.,LTD
300000-3FFFFF     (base 16)		SHENZHEN WISEWING INTERNET TECHNOLOGY CO.,LTD
				No.826,Zone 1,Block B,Famous industrial product display purchasing center,Baoyuan Road,Xixiang,Bao'an Dis., Shenzhen,P.R.China
				shenzhen  China  518102
				CN

88-A9-A7   (hex)		Thomas & Darden, Inc
400000-4FFFFF     (base 16)		Thomas & Darden, Inc
				916 Springdale Rd Bldg 4 #104
				Austin    78702
				US

F0-41-C8   (hex)		Powervault Ltd
B00000-BFFFFF     (base 16)		Powervault Ltd
				29 Shand Street, London Bridge
				London    SE1 2ES
				GB

A4-DA-22   (hex)		EHO.LINK
C00000-CFFFFF     (base 16)		EHO.LINK
				5 Avenue de Saint Menet, Imm. Axiome, Bat. B
				Marseille    13011
				FR

88-A9-A7   (hex)		Zhejiang Haoteng Electronic Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Zhejiang Haoteng Electronic Technology Co.,Ltd.
				Zhejiang Lishui city streets Nanming mountain Shek road Liandu District No. 268 Building 2 block B
				Lishui  Zhejiang  323000
				CN

DC-E5-33   (hex)		Giant Power Technology Biomedical Corporation
E00000-EFFFFF     (base 16)		Giant Power Technology Biomedical Corporation
				Rm201, 2nd Educational Building, No. 84, Gongzhuan Rd, Taishan Dist
				New Taipei City    24301
				TW

DC-E5-33   (hex)		Suzhou ATES electronic technology co.LTD
D00000-DFFFFF     (base 16)		Suzhou ATES electronic technology co.LTD
				NO.2 aimin road,Xiangcheng district
				 Suzhou city  Jiangsu Province  215002
				CN

DC-E5-33   (hex)		BRCK
C00000-CFFFFF     (base 16)		BRCK
				PO Box 58275-00200, 2nd Floor Bishop Magua Center, George Padmore Lane, 2nd Floor Bishop Magua Center, George Padmore Lane
				Nairobi  Nairobi  00200
				KE

DC-E5-33   (hex)		shenzhen bangying electronics co,.ltd
400000-4FFFFF     (base 16)		shenzhen bangying electronics co,.ltd
				3/F Building 16,Hongfa industrialPark,Tangtou Shiyan Town
				shenzhen  guangdong  518000
				CN

DC-E5-33   (hex)		Tiertime Corporation
900000-9FFFFF     (base 16)		Tiertime Corporation
				2398 Walsh Avenue
				Santa Clara  CA  95051
				US

DC-E5-33   (hex)		FLYHT Aerospace
000000-0FFFFF     (base 16)		FLYHT Aerospace
				300E 1144 - 29th St. N.E.
				Calgary  AB  T2E7P1
				CA

9C-43-1E   (hex)		SuZhou Jinruiyang Information Technology CO.,LTD
C00000-CFFFFF     (base 16)		SuZhou Jinruiyang Information Technology CO.,LTD
				NO.1003 Room A1 Buliding Tengfei Business Park in Suzhou Industrial Park.
				Suzhou  Jiangsu  215123
				CN

9C-43-1E   (hex)		JNL Technologies Inc
B00000-BFFFFF     (base 16)		JNL Technologies Inc
				W1205 Industrial Dr
				Ixonia  WI  53036
				US

C4-FF-BC   (hex)		iMageTech CO.,LTD.
400000-4FFFFF     (base 16)		iMageTech CO.,LTD.
				5F., No.16, Lane 15, Sec. 6, Mincyuan E. Rd., Neihu District,
				TAIPEI    114
				TW

C4-FF-BC   (hex)		SHENZHEN KALIF ELECTRONICS CO.,LTD
300000-3FFFFF     (base 16)		SHENZHEN KALIF ELECTRONICS CO.,LTD
				1、2 and 3 Floor, No.114, Haochong No.2 Industry Area, Hongxing Community, Songgang, Baoan, Shenzhen 
				SHENZHEN  GuangDong  518105
				CN

28-2C-02   (hex)		Epoch International Enterprises, Inc.
C00000-CFFFFF     (base 16)		Epoch International Enterprises, Inc.
				10542 Calle Lee, #114
				Los Alamitos  CA  90720
				US

28-2C-02   (hex)		EFENTO T P SZYDŁOWSKI K ZARĘBA SPÓŁKA JAWNA
400000-4FFFFF     (base 16)		EFENTO T P SZYDŁOWSKI K ZARĘBA SPÓŁKA JAWNA
				Dietla 93/6
				Kraków    31-031
				PL

F8-B5-68   (hex)		PT. Eyro Digital Teknologi
100000-1FFFFF     (base 16)		PT. Eyro Digital Teknologi
				Jalan Amir Mahmud IX/23
				Surabaya  Jawa Timur  60294
				ID

40-48-FD   (hex)		RL Controls LLC.
300000-3FFFFF     (base 16)		RL Controls LLC.
				2 G Gill St
				Woburn  MA  01801
				US

40-48-FD   (hex)		Dynamic Engineering
400000-4FFFFF     (base 16)		Dynamic Engineering
				Dynamic Engineering, 150 DuBois St. Suite C
				Santa Cruz  CA  95060
				US

40-48-FD   (hex)		Magenta Labs, Inc.
B00000-BFFFFF     (base 16)		Magenta Labs, Inc.
				P.O. BOX 77234
				San Francisco  CA  94107
				US

40-48-FD   (hex)		Fast Programming
100000-1FFFFF     (base 16)		Fast Programming
				Alyarmouk
				Riyadh  Ar Riyadh  13251
				SA

40-48-FD   (hex)		SMART SENSOR DEVICES AB
E00000-EFFFFF     (base 16)		SMART SENSOR DEVICES AB
				Sollentunavägen 67A
				Sollentuna  Stockholm  19140
				SE

38-73-EA   (hex)		Eyesight(Shanghai)Communication Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Eyesight(Shanghai)Communication Technology Co.,Ltd.
				Room 820, C/F, Building 1, NO. 3000 Longdong Avenue, China(Shanghai) Pilot Free Trade
				ShangHai  ShangHai  201203
				CN

38-73-EA   (hex)		L-3 Communications Mobile-Vision, Inc.
000000-0FFFFF     (base 16)		L-3 Communications Mobile-Vision, Inc.
				400 Commons Way STE F
				Rockaway    07866
				US

38-73-EA   (hex)		Rock Electronic Co., Ltd.
800000-8FFFFF     (base 16)		Rock Electronic Co., Ltd.
				No. 1 Chuangsheng Rd. 
				shenzhen  Guangdong  518055
				CN

EC-9F-0D   (hex)		Paw-Taw-John Services, Inc.
500000-5FFFFF     (base 16)		Paw-Taw-John Services, Inc.
				18125 N Ramsey Rd
				Rathdrum  ID  83858-8288
				US

EC-9F-0D   (hex)		Hesai Photonics Technology Co., Ltd
000000-0FFFFF     (base 16)		Hesai Photonics Technology Co., Ltd
				10th Floor, Building L2-B, Hongqiao World Center
				Shanghai  Shanghai  200010
				CN

EC-9F-0D   (hex)		Sarcos Corp
C00000-CFFFFF     (base 16)		Sarcos Corp
				360 S Wakara Way
				Salt Lake City  UT  84108
				US

EC-9F-0D   (hex)		FCI
900000-9FFFFF     (base 16)		FCI
				B-7F,Silicon Park, 35, Pangyo-ro 255 beon-gil,Bundang-gu
				Seongnam si  Gyeonggi-do. KOREA  13486
				KR

EC-9F-0D   (hex)		Bei jing Lian Shan times Techonology Co.Ltd
700000-7FFFFF     (base 16)		Bei jing Lian Shan times Techonology Co.Ltd
				Beijing Haidian.No.2 of Yong Cheng North Road Building 1.402
				Beijing    100094
				CN

34-D0-B8   (hex)		eesy-innovation GmbH
500000-5FFFFF     (base 16)		eesy-innovation GmbH
				Otto-Hahn-Str. 13b
				Munich  Bavaria  85521
				DE

34-D0-B8   (hex)		Vtrek Group International Ltd.
800000-8FFFFF     (base 16)		Vtrek Group International Ltd.
				Room 1204,12/F.,Tower1,Silvercord,30 Canton Road,Tsim Sha Tsui
				Hong Kong    999077
				HK

34-D0-B8   (hex)		Blustream Pty Ltd
200000-2FFFFF     (base 16)		Blustream Pty Ltd
				24 Lionel Road
				Mt. Waverley  Victoria  3149
				AU

AC-1D-DF   (hex)		CRDE
300000-3FFFFF     (base 16)		CRDE
				ZI DES GRANDS CAMPS
				MERCUES  LOT  46090
				FR

34-D0-B8   (hex)		Tascent, Inc.
300000-3FFFFF     (base 16)		Tascent, Inc.
				475 Alberto Way, Suite #200
				Los Gatos  CA  95032
				US

74-1A-E0   (hex)		SAIERCOM CORPORATION
A00000-AFFFFF     (base 16)		SAIERCOM CORPORATION
				ROOM 11501,FLOOR 15,UNIT 1,BLOCK 1,RENOVATION CENTER,TUANJIE SOUTH RD.,HI-TECH ZONE,XIAN,SHAANXI
				XIAN  SHAANXI  710065
				CN

74-1A-E0   (hex)		Blocks Wearables Inc.
600000-6FFFFF     (base 16)		Blocks Wearables Inc.
				1800 Century Park East, 10th Floor
				Los Angeles  CA  90067
				US

74-1A-E0   (hex)		Voltaware Services Limited
D00000-DFFFFF     (base 16)		Voltaware Services Limited
				230 High Street
				Swanage    BH19 2PQ
				GB

54-9A-11   (hex)		Elotech Industrieelektronik GmbH
500000-5FFFFF     (base 16)		Elotech Industrieelektronik GmbH
				Verbindungsstr. 27
				Hilden  NRW  40723
				DE

CC-22-37   (hex)		SHANGHAI CARGOA M.&E.EQUIPMENT CO.LTD
400000-4FFFFF     (base 16)		SHANGHAI CARGOA M.&E.EQUIPMENT CO.LTD
				98 shunda road 9#,nanxiang town, Jianding district
				Shanghai, 200182P.R.    200182
				CN

CC-22-37   (hex)		Hebei ZHSF Technology Co.,Ltd.
C00000-CFFFFF     (base 16)		Hebei ZHSF Technology Co.,Ltd.
				88 Xinshi South Road
				Shijiazhuang, Hebei    050000
				CN

CC-22-37   (hex)		XConnect Professional Services
300000-3FFFFF     (base 16)		XConnect Professional Services
				459 Westlake Dr
				Brisbane  QLD  4074
				AU

2C-27-9E   (hex)		AudioNord Distribution A/S
500000-5FFFFF     (base 16)		AudioNord Distribution A/S
				Moelbakvej 4
				Lystrup    8520
				DK

18-9B-A5   (hex)		ChengDu Vantron Technology, Ltd.
100000-1FFFFF     (base 16)		ChengDu Vantron Technology, Ltd.
				6th Floor, 1st  Building,No.9, 3rd WuKe East Street, WuHou District,
				ChengDu  SiChuan  610045
				CN

90-4E-91   (hex)		CUTTER Systems spol. s r.o.
900000-9FFFFF     (base 16)		CUTTER Systems spol. s r.o.
				Milicova 2530/26
				Prostejov    79601
				CZ

90-4E-91   (hex)		mcf88 SRL
500000-5FFFFF     (base 16)		mcf88 SRL
				Via Roma, 3
				Sozzago  Novara  28060
				IT

90-4E-91   (hex)		IBM
700000-7FFFFF     (base 16)		IBM
				9000 south rita rd
				Tucson  AZ  85744
				US

90-4E-91   (hex)		North Pole Engineering, Inc.
200000-2FFFFF     (base 16)		North Pole Engineering, Inc.
				221 N. 1st. St., Suite 310
				Minneapolis  MN  55401
				US

50-FF-99   (hex)		Informa LLC
E00000-EFFFFF     (base 16)		Informa LLC
				215 N. College Ave
				Indianapolis  IN  46202
				US

90-4E-91   (hex)		Nuwa Robotics (HK) Limited Taiwan Branch
600000-6FFFFF     (base 16)		Nuwa Robotics (HK) Limited Taiwan Branch
				9F., No.101, Sec. 3, Nanjing E. Rd., Zhongshan Dist.
				Taipei    10487
				TW

90-4E-91   (hex)		Spirtech
000000-0FFFFF     (base 16)		Spirtech
				29 rue du Louvre
				Paris    75002
				FR

34-29-8F   (hex)		Shenzhen Advance River System Technology Co., Ltd
200000-2FFFFF     (base 16)		Shenzhen Advance River System Technology Co., Ltd
				6/F South Factory,2nd Jinxiang Building,Xinzhou South Road,Futian District,
				Shenzhen  Guangdong  518048
				CN

34-00-8A   (hex)		ChengDu HuiZhong Cloud Information Technology Co., Ltd.
D00000-DFFFFF     (base 16)		ChengDu HuiZhong Cloud Information Technology Co., Ltd.
				NO.1 CHENGJI ROAD ,CHENGHUA DISTRICT
				CHENGDU CITY  SICHUAN  610000
				CN

28-F5-37   (hex)		Shenzhen Modern Cowboy Technology Co.,Ltd.     
700000-7FFFFF     (base 16)		Shenzhen Modern Cowboy Technology Co.,Ltd.     
				Room 1006,Beike building，Keyuan road,Yuehai streets,Nanshan District
				Shenzhen  Guangdong Province  518200
				CN

28-F5-37   (hex)		PRIMETECH ENGINEERING CORP.
300000-3FFFFF     (base 16)		PRIMETECH ENGINEERING CORP.
				 Koishikawadaikoku Bldg. 3F, 1-3-25
				 Koishikawa, Bunkyo-ku  Tokyo  112-0002
				JP

34-00-8A   (hex)		Keruyun Technoligies(Beijing) Corporation Limited
900000-9FFFFF     (base 16)		Keruyun Technoligies(Beijing) Corporation Limited
				Room 405, Taibang Technical Building, High-tech south 4 road, Nanshan
				Shenzhen  Guangdong  518000
				CN

34-00-8A   (hex)		RPE Monitor
200000-2FFFFF     (base 16)		RPE Monitor
				Krasnokursantskaya 104a
				Rostov-on-Don  Select  344068
				RU

34-00-8A   (hex)		Shenzhen Eternal Idea Tech Co.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen Eternal Idea Tech Co.,Ltd
				5/F, Building C, Chuangwei Technology Park,1st Rd,Shiyan tangtou,Baoan District, Shenzhen, Guang Dong Province,PRC 
				Shenzhen  Guang Dong  518000
				CN

34-00-8A   (hex)		Fotonic i Norden AB
400000-4FFFFF     (base 16)		Fotonic i Norden AB
				Box 733
				Skelleftea  SE  93127
				SE

28-F5-37   (hex)		Umojo
100000-1FFFFF     (base 16)		Umojo
				1 E. Superior St., Suite 402
				Chicago  IL  60611
				US

28-F5-37   (hex)		Atomrock LLC
500000-5FFFFF     (base 16)		Atomrock LLC
				22525 SE 64th Place, Suite 2288
				Issaquah    98027
				US

28-F5-37   (hex)		Skyrockettoys LLC
D00000-DFFFFF     (base 16)		Skyrockettoys LLC
				12910 culver blvd Ste F
				los angeles  CA  90066
				US

28-F5-37   (hex)		Valeo Siemens eAutomotive Norway
000000-0FFFFF     (base 16)		Valeo Siemens eAutomotive Norway
				Graaterudveien 41
				Drammen  Buskerud  3036
				NO

28-F5-37   (hex)		LogiM GmbH Software und Entwicklung
B00000-BFFFFF     (base 16)		LogiM GmbH Software und Entwicklung
				Mahonienweg 22b
				Berlin    12437
				DE

78-D8-00   (hex)		Insignal Co., Ltd.
A00000-AFFFFF     (base 16)		Insignal Co., Ltd.
				#301, Ace High-end Tower 1st, 5 Digital-ro 26-gil
				Seoul    ASI KR KS013 SEOUL
				KR

7C-BA-CC   (hex)		Sun Asia Trade Co.
400000-4FFFFF     (base 16)		Sun Asia Trade Co.
				RM 1005 10/F, HOKING COMMERCIAL CENTRE,2-16 FA YUEN STREET MONGKOk
				Hong Kong  Hong Kong  9998800
				HK

7C-BA-CC   (hex)		Changsha SUNYE Electric Co., Ltd.
100000-1FFFFF     (base 16)		Changsha SUNYE Electric Co., Ltd.
				hi tech Zone, Sheng Xin Road, No. 669
				Changsha   Hunan  410000
				CN

78-D8-00   (hex)		CS Instruments GmbH
400000-4FFFFF     (base 16)		CS Instruments GmbH
				Zindelsteiner Straße 15
				 VS-Tannheim    78052
				DE

AC-64-DD   (hex)		HMicro Inc
D00000-DFFFFF     (base 16)		HMicro Inc
				39355 California St., Suite 303
				Fremont  null  94538
				US

4C-65-A8   (hex)		Suzhou Embedded Electronic Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Suzhou Embedded Electronic Technology Co., Ltd.
				Room 15A05, KeJi GuangChang,QianJinDong Road
				Kunshan  Jiangsu  215300
				CN

F8-8A-3C   (hex)		Shenzhen Shengyuan Tech Ltd.
300000-3FFFFF     (base 16)		Shenzhen Shengyuan Tech Ltd.
				Science and Technology Park North District, high tech North six Road, LAN LAN Technology Park, building C-309,Shenzhen Nanshan District, Guangdong Province, China
				shenzhen  guangdong  518000
				CN

4C-65-A8   (hex)		Roost
300000-3FFFFF     (base 16)		Roost
				955, Benecia Ave
				Sunnyvale  CA  94085
				US

F8-8A-3C   (hex)		KLATU Networks Inc
200000-2FFFFF     (base 16)		KLATU Networks Inc
				4174 NE Lookout Lane
				Poulsbo  WA  98370
				US

A0-C5-F2   (hex)		Synapsys Solutions Ltd.
E00000-EFFFFF     (base 16)		Synapsys Solutions Ltd.
				1 Woodlands Court, Albert Drive
				Burgess Hill  West Sussex  RH15 9TN
				GB

A0-C5-F2   (hex)		KNS Group LLC (YADRO Company)
100000-1FFFFF     (base 16)		KNS Group LLC (YADRO Company)
				Spartakovskaya sq., 14, bl. 1
				Moscow    105082
				RU

A0-C5-F2   (hex)		Speedgoat GmbH
200000-2FFFFF     (base 16)		Speedgoat GmbH
				Waldeggstrasse 30
				Liebefeld  BE  3097
				CH

A0-C5-F2   (hex)		Viettronimex JSC
700000-7FFFFF     (base 16)		Viettronimex JSC
				74-76 Nguyen Hue street, Ben nghe ward, distric 1
				Ho Chi Minh    70000
				VN

04-71-4B   (hex)		Neurio Technology Inc.
000000-0FFFFF     (base 16)		Neurio Technology Inc.
				43 West Hastings Street
				Vancouver  BC  V6B 1G4
				CA

04-71-4B   (hex)		Lighthouse AI, Inc
900000-9FFFFF     (base 16)		Lighthouse AI, Inc
				380 Portage Ave
				Palo Alto  CA  94306
				US

F0-23-B9   (hex)		Emu Technology
900000-9FFFFF     (base 16)		Emu Technology
				1400 E. Angela Blvd. #101
				South Bend  IN  46617
				US

F0-23-B9   (hex)		Audeara Pty. Ltd.
500000-5FFFFF     (base 16)		Audeara Pty. Ltd.
				375 Wickham Terrace
				Brisbane  Queensland  4000
				AU

60-D7-E3   (hex)		Elap s.r.l.
100000-1FFFFF     (base 16)		Elap s.r.l.
				Via V. Veneto 4
				Corsico  Milano  20094
				IT

04-71-4B   (hex)		DIGIBEST TECHNOLOGY CO., LTD.
B00000-BFFFFF     (base 16)		DIGIBEST TECHNOLOGY CO., LTD.
				4F ,No.65 , SHITAN ROAD , NEIHU DIST.
				TAIPEI    114
				TW

04-71-4B   (hex)		KittyHawk Corporation
C00000-CFFFFF     (base 16)		KittyHawk Corporation
				2700 Broderick Way
				Mountain View  CA  94043
				US

1C-C0-E1   (hex)		SHENZHEN KINSTONE D&T DEVELOP CO.,LTD
700000-7FFFFF     (base 16)		SHENZHEN KINSTONE D&T DEVELOP CO.,LTD
				5F, A2 Building ,XinJianXing Tech Industrial Park,Fengxin Road ,Lou Cun , Gongming Street,Guangming New Dist.,
				 Shenzhen  Guangdong  518000
				CN

08-ED-02   (hex)		Eleven Engineering Incorporated
700000-7FFFFF     (base 16)		Eleven Engineering Incorporated
				10150 - 100 Street, Suite 800
				Edmonton  Canada, Alberta  T5J 0P6
				CA

08-ED-02   (hex)		TES Touch Embedded Solutions Inc.
200000-2FFFFF     (base 16)		TES Touch Embedded Solutions Inc.
				3F, No. 141, Sec. 3, Ren'ai Rd.,
				Taipei    106
				TW

98-AA-FC   (hex)		Resonant Systems Inc.
B00000-BFFFFF     (base 16)		Resonant Systems Inc.
				Tsurumi chiyoda building,4-34-26,Tsurumi-tyuou,Tsurumi
				Yokohama-shi  kanagawa-ken  230-0051
				JP

98-AA-FC   (hex)		Shenzhen UniStrong Science & Technology Co., Ltd
200000-2FFFFF     (base 16)		Shenzhen UniStrong Science & Technology Co., Ltd
				B，4-4Factory,Zhengcheng Road, Fuyong Baoan District,
				Shenzhen    518103
				CN

98-AA-FC   (hex)		SENKO Co.,Ltd.
A00000-AFFFFF     (base 16)		SENKO Co.,Ltd.
				73 Oesammiro15beon-gil 
				Osan-si  Gyeonggi-do  18111
				KR

08-ED-02   (hex)		HANTAS CO., LTD.
800000-8FFFFF     (base 16)		HANTAS CO., LTD.
				474 Dunchondaero, Jungwon-gu
				Seongnam-si  Kyonggi-do  13229
				KR

14-4F-D7   (hex)		Red Technology Limited
400000-4FFFFF     (base 16)		Red Technology Limited
				Room 702, 7/F., Fu Fai Commercial Centre, 27 Hillier Street, Sheung Wan
				Hong Kong    999077
				HK

14-4F-D7   (hex)		Qingdao Wodatong Electronics Co., Ltd.
300000-3FFFFF     (base 16)		Qingdao Wodatong Electronics Co., Ltd.
				West of Committees, HouHaiXi Community, JiHongTan Street, Chengyang District,
				Qingdao  Shandong  266111
				CN

14-4F-D7   (hex)		Unirobot Corporation
A00000-AFFFFF     (base 16)		Unirobot Corporation
				MK Hatagaya Sasazuka building 6F, Hatagaya, Shibuya-ku
				Tokyo  Japan  1510072
				JP

A4-11-63   (hex)		Beijing XiaoRui Technology Co., Ltd
600000-6FFFFF     (base 16)		Beijing XiaoRui Technology Co., Ltd
				Room 1201, Zhongqing Building, East Third Ring Road, Chaoyang District, Beijing
				Beijing  Beijing  100029
				CN

1C-A0-D3   (hex)		NovTech, Inc.
200000-2FFFFF     (base 16)		NovTech, Inc.
				7401 Wiles Road, Suite 229
				Coral Springs  FL  33067
				US

40-F3-85   (hex)		URMET Home & Building Solutions Pty Ltd
B00000-BFFFFF     (base 16)		URMET Home & Building Solutions Pty Ltd
				36 Ricketty Street
				Mascot  NSW  2020
				AU

40-F3-85   (hex)		Johnson Matthey
100000-1FFFFF     (base 16)		Johnson Matthey
				MTC, The Moat
				Billingham  Cleveland  TS23 4ED
				GB

8C-C8-F4   (hex)		Beijing KXWELL Technology CO., LTD 
500000-5FFFFF     (base 16)		Beijing KXWELL Technology CO., LTD 
				 Room 12A05, North Real Estate Building, Block 3
				81 Zizhuyuan Road, Haidian District  Beijing   100089
				CN

40-F3-85   (hex)		Clixxo Broadband Private Limited
C00000-CFFFFF     (base 16)		Clixxo Broadband Private Limited
				Suite # 10, 3rd Floor, Tower 2, Stellar IT Park, C-25, Sector 62
				Noida  Uttar Pradesh  201301
				IN

50-A4-D0   (hex)		Beijing YangLian Networks Technology co., LTD
C00000-CFFFFF     (base 16)		Beijing YangLian Networks Technology co., LTD
				Building 17, East Zone, No.10 Xibeiwang Dong Rd, Haidian District, Beijing, PRC
				BeiJing    100193
				CN

8C-C8-F4   (hex)		Beijing Xinxunxintong Eletronics Co.,Ltd
D00000-DFFFFF     (base 16)		Beijing Xinxunxintong Eletronics Co.,Ltd
				No.9 Yingfu Road,Haidian District
				Beijing    100192
				CN

8C-C8-F4   (hex)		PTYPE Co., LTD.
B00000-BFFFFF     (base 16)		PTYPE Co., LTD.
				B121, B-dong, Keumkang Penterium IT Tower, 810, Gwanyand 2-dong, Dongan-gu
				Anyang-si  Gyeonggi-do  14056
				KR

50-A4-D0   (hex)		Guangzhou Hysoon Electronic Co., Ltd.
300000-3FFFFF     (base 16)		Guangzhou Hysoon Electronic Co., Ltd.
				No.1, Fenghuang South Road, Xinhua, Huadu District
				Guangzhou  Guangdong  510800
				CN

34-04-9E   (hex)		Harbin Yantuo Science and Technology Development Co., Ltd
400000-4FFFFF     (base 16)		Harbin Yantuo Science and Technology Development Co., Ltd
				No. 15 Xingnan Road, Nangang District
				Harbin  Heilongjiang Province  150000
				CN

40-ED-98   (hex)		Hangzhou GANX Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Hangzhou GANX Technology Co.,Ltd.
				Room 502, Building 2, No 1180, BinAn Rd, Binjiang District
				Hangzhou  Zhejiang  310000
				CN

40-ED-98   (hex)		TeraTron GmbH
900000-9FFFFF     (base 16)		TeraTron GmbH
				Bunsenstr. 10
				Gummersbach  DE  51647
				DE

40-ED-98   (hex)		BORDA TECHNOLOGY
E00000-EFFFFF     (base 16)		BORDA TECHNOLOGY
				ITU ARI TEKNOKENT ARI 3 NO 504
				ISTANBUL    34369
				TR

50-0B-91   (hex)		EWIN TECHNOLOGY LIMITED
300000-3FFFFF     (base 16)		EWIN TECHNOLOGY LIMITED
				3rd floor, No. 12, LIYE Road, 2nd industrial District, South Zone,
				Zhongshan  Guangdong  528400
				CN

50-0B-91   (hex)		Security Alarms & Co. S.A.
600000-6FFFFF     (base 16)		Security Alarms & Co. S.A.
				Z.I. Tresi 6D
				Preverenges    1028
				CH

A4-58-0F   (hex)		Changsha Tai Hui Network Technology Co.,Ltd
700000-7FFFFF     (base 16)		Changsha Tai Hui Network Technology Co.,Ltd
				102-202 Building A2,Luguyu Garden,No.27 Wenxuan Rd,Gaoxin District,Changsha
				changsha  hunan  410205
				CN

A4-58-0F   (hex)		ABB AB PGHV
B00000-BFFFFF     (base 16)		ABB AB PGHV
				Lyviksvägen 4
				Ludvika    77180
				SE

A4-58-0F   (hex)		Engineered SA
300000-3FFFFF     (base 16)		Engineered SA
				Avenue des Sports 28
				Yverdon-les-Bains  VD  1400
				CH

7C-CB-E2   (hex)		optilink networks pvt ltd
D00000-DFFFFF     (base 16)		optilink networks pvt ltd
				501/502, sanjona complex, hemu kalani marg, chembur
				mumbai  maharashtra  400071
				IN

7C-CB-E2   (hex)		Ningbo bird sales co.,LTD
400000-4FFFFF     (base 16)		Ningbo bird sales co.,LTD
				NO.999 Dacheng East Road
				Fenghua City  Zhejiang Province  315559
				CN

48-65-EE   (hex)		CNU
E00000-EFFFFF     (base 16)		CNU
				No.8 Everygreen Road,  Haidian District 3 layer 313
				Beijing    100195
				CN

48-65-EE   (hex)		Swistec Systems AG
500000-5FFFFF     (base 16)		Swistec Systems AG
				Allmendstrasse 30
				Fehraltorf  ZH  8320
				CH

10-07-23   (hex)		Shenzhen Xinfa Electronic Co.,ltd
C00000-CFFFFF     (base 16)		Shenzhen Xinfa Electronic Co.,ltd
				 NO.57., Baoli Rd.,Buji Town.,Longgang District.,Shenzhen city.,guangdong province.,China
				shenzhen  guangdong  518112
				CN

24-4E-7B   (hex)		sonoscape
100000-1FFFFF     (base 16)		sonoscape
				yuquan road
				shenzhen  guangdong  518052
				CN

24-4E-7B   (hex)		Mighty Audio, Inc.
B00000-BFFFFF     (base 16)		Mighty Audio, Inc.
				707 Coeur d'Alene Ave
				Venice  CA  90291
				US

24-4E-7B   (hex)		Shenzhen Ruixunyun Technology Co.,Ltd.
300000-3FFFFF     (base 16)		Shenzhen Ruixunyun Technology Co.,Ltd.
				Rm 311, 2Bldg.,Xunmei Technology Plaza, Keyuan Avenue, Nanshan District
				Shenzhen  Guangdong   518057
				CN

24-4E-7B   (hex)		CHUNGHSIN TECHNOLOGY GROUP CO.,LTD
C00000-CFFFFF     (base 16)		CHUNGHSIN TECHNOLOGY GROUP CO.,LTD
				618-2#GONGREN WEST ROAD,JIAOJIANG AREA
				TAIZHOU  ZHEJIANG  318000
				CN

1C-C0-E1   (hex)		Abbott Medical Optics Inc.
200000-2FFFFF     (base 16)		Abbott Medical Optics Inc.
				510 Cottonwood Drive
				Milpitas  CA  95035
				US

1C-C0-E1   (hex)		Monument Labs, Inc.
600000-6FFFFF     (base 16)		Monument Labs, Inc.
				222 W. Merchandise Mart Plaza Ste 1212
				Chicago  IL  60654
				US

4C-E1-73   (hex)		KTC(K-TEL)
D00000-DFFFFF     (base 16)		KTC(K-TEL)
				98, Sandan-ro 132beon-gil
				Uijeongbu-si  Gyeonggi-do  11781
				KR

AC-64-DD   (hex)		Beijing Hamigua Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Beijing Hamigua Technology Co., Ltd.
				Building C 02B-322, No.28A, Information Road, Haidian District
				BEIJING  BEIJING  100000
				CN

4C-E1-73   (hex)		 Beijing Sutongwang E-Business Co., Ltd
000000-0FFFFF     (base 16)		 Beijing Sutongwang E-Business Co., Ltd
				 Room 1108, Qingyun modern building. NO.43 Bei San Huan Xi Road
				Beijing  Beijing  100086
				CN

38-3A-21   (hex)		Mission Embedded GmbH
C00000-CFFFFF     (base 16)		Mission Embedded GmbH
				Gutheil-Schoder-Gasse 8-12
				Wien  Wien  1100
				AT

F8-1D-78   (hex)		DACONS
500000-5FFFFF     (base 16)		DACONS
				90, Centum jungang-ro, Haeundae-gu
				Busan    48059
				KR

38-3A-21   (hex)		Shanghai Greatwall Safety System Co.,Ltd
300000-3FFFFF     (base 16)		Shanghai Greatwall Safety System Co.,Ltd
				502B - Bloc ,No.168 Luoyang Str
				ShangHai    201100
				CN

F8-1D-78   (hex)		Ophrys Systèmes
900000-9FFFFF     (base 16)		Ophrys Systèmes
				6 rue Valérien Perrin
				Seyssinet    38170
				FR

70-F8-E7   (hex)		Dr. Simon Consulting GmbH
300000-3FFFFF     (base 16)		Dr. Simon Consulting GmbH
				Friedrichstr. 35
				Göppingen    73033
				DE

F8-1D-78   (hex)		Xperio Labs Limited
200000-2FFFFF     (base 16)		Xperio Labs Limited
				Unit 3709, 37th Floor, Tower II, Lippo Centre, 89 Queensway, Admiralty,
				Hong Kong  Hong Kong  Hong Kong
				HK

70-F8-E7   (hex)		TiVACI CORPORATION PTE LTD
A00000-AFFFFF     (base 16)		TiVACI CORPORATION PTE LTD
				264A Tanjong Katong Road
				Singapore    437051
				SG

84-E0-F4   (hex)		AIMTRON CORPORATION
C00000-CFFFFF     (base 16)		AIMTRON CORPORATION
				555 S VERMONT ST
				PALATINE  IL  60067
				US

84-E0-F4   (hex)		ASL Intercom B.V.
300000-3FFFFF     (base 16)		ASL Intercom B.V.
				Zonnebaan 42
				Utrecht    3542EG
				NL

84-E0-F4   (hex)		Orchard Electronics Co., Ltd.
B00000-BFFFFF     (base 16)		Orchard Electronics Co., Ltd.
				8F,No.2,Lane 235,Bao-Chiao Rd., Hsin-Tien District,
				New Taipei City    23145
				TW

C0-D3-91   (hex)		SAMSARA NETWORKS INC
E00000-EFFFFF     (base 16)		SAMSARA NETWORKS INC
				525 York St
				San Francisco  CA  94110
				US

C0-D3-91   (hex)		Alpha Audiotronics, Inc.
A00000-AFFFFF     (base 16)		Alpha Audiotronics, Inc.
				401 Park Avenue South, Fl. 10
				New York  NY  10016
				US

C0-D3-91   (hex)		Zhinengguo technology company limited
C00000-CFFFFF     (base 16)		Zhinengguo technology company limited
				Taiyueshangwu building, Luozhuang East road, Haidian District
				beijing  beijing  100088
				CN

84-E0-F4   (hex)		ShenZhen Panrich Technology Limited
000000-0FFFFF     (base 16)		ShenZhen Panrich Technology Limited
				room 1321 qinghai building,beihuan rd,futian district
				shenzhen    518034
				CN

58-E8-76   (hex)		TEM Mobile Limited
900000-9FFFFF     (base 16)		TEM Mobile Limited
				RM1703, North Block, Cangsong Building, Tairan 6 road, Futian District, Shenzhen.
				Shenzhen  Guangdong  518000
				CN

C0-D3-91   (hex)		WiTagg, Inc
500000-5FFFFF     (base 16)		WiTagg, Inc
				1045 Linda Vista Avenue
				Mountain View    94043
				US

F0-AC-D7   (hex)		Smart Power Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Smart Power Technology Co., Ltd.
				Room 102,Unit A,Building 32,No.999,Gaoxinqi Road, High Tech Industrial Development Zone,Nanchang,Jiangxi
				 Nanchang City  Jiangxi Province  330096
				CN

58-E8-76   (hex)		PROBIT SRL
400000-4FFFFF     (base 16)		PROBIT SRL
				Pantelimon, 1
				Bucharest    021591
				RO

F0-AC-D7   (hex)		Groupeer Technologies
A00000-AFFFFF     (base 16)		Groupeer Technologies
				17 avenue Georges 5
				Paris  Ile-de-France  75008
				FR

28-36-38   (hex)		Shenzhen  Zhi Hua  Creative Technology  Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen  Zhi Hua  Creative Technology  Co., Ltd.
				Bao`an District,  Shenzhen Baoan  District  Xixiang  Bao yuan road beach village in the 8-905 room
				Shenzhen    518000
				CN

5C-F2-86   (hex)		Hangzhou Signwei Electronics Technology Co., Ltd
000000-0FFFFF     (base 16)		Hangzhou Signwei Electronics Technology Co., Ltd
				408 Room, 7 Cuibai Road,xihu District
				 Hangzhou  Zhejiang  310012
				CN

28-36-38   (hex)		Panasonic System Solutions Europe
100000-1FFFFF     (base 16)		Panasonic System Solutions Europe
				Panasonic Marketing Europe GmbH, Hagenauer Str. 43
				Wiesbaden    65203
				DE

8C-19-2D   (hex)		ELCO(TIANJIN)ELECTRONICS CO.,LTD.
500000-5FFFFF     (base 16)		ELCO(TIANJIN)ELECTRONICS CO.,LTD.
				NO. 12 4th XEDA Branch Road,XiQing Economic Development Area
				Tianjin    300385
				CN

D0-D9-4F   (hex)		Teco Image Systems Co., Ltd.
200000-2FFFFF     (base 16)		Teco Image Systems Co., Ltd.
				2F., No. 1568-1, Chung Shan Road, Sec. 1, Kuang-In
				Taoyuan    328
				TW

D0-D9-4F   (hex)		Hyundai Autohow
600000-6FFFFF     (base 16)		Hyundai Autohow
				Starwith 0914, Heungandaero427-38
				Anyang  Gyunggi  14059
				KR

D0-D9-4F   (hex)		Hangzhou xiaoben technology co.,Ltd
900000-9FFFFF     (base 16)		Hangzhou xiaoben technology co.,Ltd
				Room 401,Building 5,No.503,Xingguo Road,Qianjiang Economic Development Area
				Hangzhou  Zhejiang  311106
				CN

D0-D9-4F   (hex)		mycable GmbH
100000-1FFFFF     (base 16)		mycable GmbH
				Gartenstrasse 10
				Neumuenster  Schleswig Holstein  24534
				DE

D0-D9-4F   (hex)		MAX Smart Home, LLC
B00000-BFFFFF     (base 16)		MAX Smart Home, LLC
				3830 Valley Centre Dr, STE 705-852
				San Diego  CA  92130
				US

CC-D3-1E   (hex)		KEN A/S
300000-3FFFFF     (base 16)		KEN A/S
				Bøgebjergvej 60
				Brobyværk  Denmark  5672
				DK

CC-D3-1E   (hex)		Neptune Systems
200000-2FFFFF     (base 16)		Neptune Systems
				15750 Vineyard Blvd Suite 150
				MORGAN HILL  CA  95037
				US

CC-D3-1E   (hex)		SAMIM Co
000000-0FFFFF     (base 16)		SAMIM Co
				No. 47/19, Iranshahr St., Tehran, Iran
				Tehran  Tehran  1581633939
				IR

CC-D3-1E   (hex)		Rondo Burgdorf AG
100000-1FFFFF     (base 16)		Rondo Burgdorf AG
				Heimiswilstrasse 42
				Burgdorf    3400
				CH

C4-7C-8D   (hex)		ATI
000000-0FFFFF     (base 16)		ATI
				30 Jeffries Street
				Boston  MA  02128
				US

68-91-D0   (hex)		femrice
600000-6FFFFF     (base 16)		femrice
				Rm408,Tower B,Jiahu Building,Shangdi 3rd Street,Haidian,Beijing,China
				Beijing    100085
				CN

C4-7C-8D   (hex)		Labor Strauss Sicherungsanlagenbau GmbH
E00000-EFFFFF     (base 16)		Labor Strauss Sicherungsanlagenbau GmbH
				Wiegelestraße 36
				Vienna    1230
				AT

C4-7C-8D   (hex)		LYNX INNOVATION LITIMED
100000-1FFFFF     (base 16)		LYNX INNOVATION LITIMED
				Unit 8A,331 Rosedale Road Albany,North Shore City 0632 Auckland,New Zealand
				Auckland    0632
				NZ

68-91-D0   (hex)		Central Railway Manufacturing
000000-0FFFFF     (base 16)		Central Railway Manufacturing
				8933 Western Way Suite 8
				Jacksonville  FL  32256
				US

68-91-D0   (hex)		Shenzhen NeaTech Intelligence Technology Co., Ltd.
200000-2FFFFF     (base 16)		Shenzhen NeaTech Intelligence Technology Co., Ltd.
				C.8F, Bofook Lilang Industry Park, Bulan Road, Nanwan Street, Longgang
				Shenzhen  Guangdong  518112
				CN

E0-B6-F5   (hex)		Shenzhen Xrinda Technology Ltd
700000-7FFFFF     (base 16)		Shenzhen Xrinda Technology Ltd
				Fl#15, Tianming Technology Building, Wushitou Road No.8, North high-tech park, Nanshan District, Shenzhen,P.R.China
				Shenzhen  Guangdong  518052
				CN

E0-B6-F5   (hex)		BeSTAR Corporation
000000-0FFFFF     (base 16)		BeSTAR Corporation
				8th F/L, UNIQUEST B/D, 314, Hwangsaeul-ro, Bundang-gu
				Seongnam-si  Gyeonggi-do  13591
				KR

50-FF-99   (hex)		Sea Eagle Optoelectronic Information Technology(Tianjin)co,Ltd
900000-9FFFFF     (base 16)		Sea Eagle Optoelectronic Information Technology(Tianjin)co,Ltd
				Nankai District
				Tianjin  Tianjin  300000
				CN

98-6D-35   (hex)		DH Mechatronic AG
300000-3FFFFF     (base 16)		DH Mechatronic AG
				Georg-Sasse-Straße 28-32
				Ammersbek  Schleswig-Holstein  22949
				DE

50-FF-99   (hex)		Simicon
000000-0FFFFF     (base 16)		Simicon
				Mendeleevskay str. 8
				Saint-Petersburg    194044
				RU

50-FF-99   (hex)		LEGEND WINNER LIMITED
600000-6FFFFF     (base 16)		LEGEND WINNER LIMITED
				FLAT/RM 18-19 13/F HOLLYWOOD PLAZA 610 NATHAN ROAD MONGKOK
				HONG kONG    00852
				HK

98-6D-35   (hex)		Shenzhen MALATA Mobile Communication Co.,LTD
000000-0FFFFF     (base 16)		Shenzhen MALATA Mobile Communication Co.,LTD
				25F, Malata Technology Building, No. 9998 Shennan Avenue, Hi-techPark, Nanshan District
				Shenzhen  GUANGDONG  518057
				CN

7C-47-7C   (hex)		Dspread Technology (Beijing) Inc.
A00000-AFFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

7C-47-7C   (hex)		BlueSmart Technology Corporation
700000-7FFFFF     (base 16)		BlueSmart Technology Corporation
				1451 Grant Road, Suite 200
				Mountain View  CA  94042
				US

7C-47-7C   (hex)		Speedifi Inc
D00000-DFFFFF     (base 16)		Speedifi Inc
				1163 Kassel Terrace
				Sunnyvale  CA  94089
				

5C-F2-86   (hex)		CHIPSEN Co.,Ltd.
400000-4FFFFF     (base 16)		CHIPSEN Co.,Ltd.
				Haan-ro 60
				Gwang-myeong  Gyeonggi-do  14322
				KR

5C-F2-86   (hex)		iSon Tech
100000-1FFFFF     (base 16)		iSon Tech
				Rm. 3, 2F., No.417, Guangfu S. Rd., Sinyi Dist.
				Taipei  Taiwan  110
				TW

38-FD-FE   (hex)		Inspero Inc
600000-6FFFFF     (base 16)		Inspero Inc
				C101, Ju'Er Hu Tong, Dong Cheng Qu
				Beijing  Beijing  100001
				CN

38-FD-FE   (hex)		FUBA Automotive Electronics GmbH
D00000-DFFFFF     (base 16)		FUBA Automotive Electronics GmbH
				Tec Center 1
				Bad Salzdetfurth    31162
				DE

38-B8-EB   (hex)		1.A Connect GmbH
100000-1FFFFF     (base 16)		1.A Connect GmbH
				Obere Seestrasse 13
				Nohfelden  Saarland  66625
				DE

78-CA-83   (hex)		Konecranes
E00000-EFFFFF     (base 16)		Konecranes
				Koneenkatu 8
				Hyvinkää    05801
				FI

38-B8-EB   (hex)		Aina Wireless Inc
300000-3FFFFF     (base 16)		Aina Wireless Inc
				Hub Salo, Tehdaskatu 6
				Salo    24100
				FI

78-CA-83   (hex)		Huatune Technology (Shanghai) Co., Ltd.
500000-5FFFFF     (base 16)		Huatune Technology (Shanghai) Co., Ltd.
				No.8 Longxi RD
				Shanghai  Changning District  200336
				CN

1C-88-79   (hex)		Sensys Networks, Inc.
700000-7FFFFF     (base 16)		Sensys Networks, Inc.
				1608 4th St. Suite 200
				Berkeley  CA  94710
				US

1C-87-74   (hex)		Schawbel Technologies LLC
600000-6FFFFF     (base 16)		Schawbel Technologies LLC
				24 New England Executive Park, Suite 150
				Burlington  MA  01803
				US

1C-87-74   (hex)		HABEY USA Inc.
B00000-BFFFFF     (base 16)		HABEY USA Inc.
				Room 205,Block A, Hua Feng Business Building ,Qian Jin 1st  Road, Baoan 25 Area, Shenzhen 518101, China.
				Shenzhen  Guang Dong  518101
				CN

1C-88-79   (hex)		Shenzhen Xiaoxi Technology Co., Ltd.
300000-3FFFFF     (base 16)		Shenzhen Xiaoxi Technology Co., Ltd.
				2F, Wing D, Building 5, Software Industry Base, No.14, Haitian 2nd Road, Nanshan District
				Shenzhen  Guangdong  518000
				CN

1C-88-79   (hex)		SHENZHENFREELINK ELECTRONIC CO.,LTD
500000-5FFFFF     (base 16)		SHENZHENFREELINK ELECTRONIC CO.,LTD
				3/F,Building A,Quanyongyuan industrial park,Langkou industrial area,Dalang,Bao'an District,Shenzhen,China 
				Shenzhen    518000
				CN

1C-87-76   (hex)		Strone Technology
C00000-CFFFFF     (base 16)		Strone Technology
				13 Ellis Street
				South Yarra  Victoria  3141
				AU

1C-87-76   (hex)		Jiangsu ETERN COMMUNICATION Co.,ltd
A00000-AFFFFF     (base 16)		Jiangsu ETERN COMMUNICATION Co.,ltd
				888 YUEXIU ROAD, LILI TOWN, WUJIANG DISTRICT, 
				Suzhou  Jiangsu  215211
				CN

1C-87-76   (hex)		Zhuhai MYZR Technology Co.,Ltd
500000-5FFFFF     (base 16)		Zhuhai MYZR Technology Co.,Ltd
				Room 302,Area D2,National Hi-tech Zone,NO.1,Software Park Road
				Zhuhai    519085
				CN

1C-88-79   (hex)		Xingtera China Ltd
900000-9FFFFF     (base 16)		Xingtera China Ltd
				88 Chenhui Rd Bldg 1 Ste 303
				Shanghai    201203
				CN

1C-87-79   (hex)		Novetta
400000-4FFFFF     (base 16)		Novetta
				7921 Jones Branch Drive
				McLean  VA  22102
				US

84-39-BE   (hex)		Neat S.r.l.
500000-5FFFFF     (base 16)		Neat S.r.l.
				via Edoardo D'Onofrio 304
				Rome  ITALY  00155
				IT

84-39-BE   (hex)		Shenzhen Ramos Digital Technology Co,.Ltd.
400000-4FFFFF     (base 16)		Shenzhen Ramos Digital Technology Co,.Ltd.
				3F,Noth Block B, No.2 Kingdee Software Park, Keji South 12th Road, High-Tech Industrial Park, Nanshan District,Shenzhen 518057
				Shenzhen  Guangdong  518000
				CN

40-A3-6B   (hex)		National Research Council of Canada
500000-5FFFFF     (base 16)		National Research Council of Canada
				717 White Lake Road
				Kaleden  British Columbia  V0H1K0
				CA

40-A3-6B   (hex)		Embrionix Design Inc.
A00000-AFFFFF     (base 16)		Embrionix Design Inc.
				2120 Monterey, suite 200
				Laval  Québec  H7L3S3
				CA

70-88-6B   (hex)		Chengdu Ophylink Communication Technology Ltd.
500000-5FFFFF     (base 16)		Chengdu Ophylink Communication Technology Ltd.
				3F,Bldg3,No.333,Yunhua Road,Hig-tech Zone
				Chengdu  Sichuan  610041
				CN

70-88-6B   (hex)		CVnet
200000-2FFFFF     (base 16)		CVnet
				111, Maeyeong-ro 345beon-gil, Yeongtong-gu
				Suwon-si  Gyeonggi-do  16703
				KR

CC-1B-E0   (hex)		Guangzhou Southelectric Power Science Technology Development Co.,Ltd.
C00000-CFFFFF     (base 16)		Guangzhou Southelectric Power Science Technology Development Co.,Ltd.
				No.1, zhongsuihua south street, Jiangnan BLVD,
				Guangzhou  Guangdong  510310
				CN

A0-3E-6B   (hex)		Jining SmartCity Infotech Co.Ltd.
D00000-DFFFFF     (base 16)		Jining SmartCity Infotech Co.Ltd.
				Technology Center,Renchen District,
				Jining  Shandong  272000
				CN

00-55-DA   (hex)		KoolPOS Inc.
100000-1FFFFF     (base 16)		KoolPOS Inc.
				5th Floor, B Section, Virgo Building,
				Wuxi  Jiangsu  214135
				CN

CC-1B-E0   (hex)		Laserworld (Switzerland) AG
400000-4FFFFF     (base 16)		Laserworld (Switzerland) AG
				Kreuzlingerstrasse 5
				Lengwil  TG  8574
				CH

00-55-DA   (hex)		Datapath Limited
400000-4FFFFF     (base 16)		Datapath Limited
				Bemrose House,
				Derby  Derbyshire  DE21 6XQ
				GB

00-55-DA   (hex)		BroadSoft, Inc.
800000-8FFFFF     (base 16)		BroadSoft, Inc.
				550 S. Winchester Blvd. Suite 250
				San Jose  California  95128
				US

00-55-DA   (hex)		Speechlab
A00000-AFFFFF     (base 16)		Speechlab
				Gaasterlandstraat 3
				Amsterdam  NH  1079RH
				NL

C8-8E-D1   (hex)		Advanced Micro Controls Inc.
B00000-BFFFFF     (base 16)		Advanced Micro Controls Inc.
				20 Gear Dr.
				Terryville  CT  06786
				US

C8-8E-D1   (hex)		Electronic Controls Design, Inc.
800000-8FFFFF     (base 16)		Electronic Controls Design, Inc.
				4287-B SE International Way
				Milwaukie  OR  97222
				US

C8-8E-D1   (hex)		Focalcrest, Ltd.
900000-9FFFFF     (base 16)		Focalcrest, Ltd.
				Shenzhen City, Futian District Tairan nine road Haisong building B, room 1101
				shenzhen  广东  518040
				CN

A0-3E-6B   (hex)		Shenzhen Neostra Technology Co.Ltd
A00000-AFFFFF     (base 16)		Shenzhen Neostra Technology Co.Ltd
				7th Building,Huaide Cuihai Industrial Park,Fuyong,
				Shenzhen  Guangdong  518000
				CN

B0-C5-CA   (hex)		SunTech Medical, Inc.
600000-6FFFFF     (base 16)		SunTech Medical, Inc.
				507 Airport Blvd.
				Morrisville  NC  27560
				US

DC-44-27   (hex)		Skywave Technology Co,.Ltd.
200000-2FFFFF     (base 16)		Skywave Technology Co,.Ltd.
				Beijing Chaoyang District, River Park 22-4-902
				Beijing  Chaoyang  100107
				CN

DC-44-27   (hex)		EK-TEAM Elektronik- u. Kunststoff-Technik GmbH
600000-6FFFFF     (base 16)		EK-TEAM Elektronik- u. Kunststoff-Technik GmbH
				Schnackenburgallee 43
				Hamburg  Hamburg  22525
				DE

DC-44-27   (hex)		EcoGuard AB
700000-7FFFFF     (base 16)		EcoGuard AB
				Radiatorvägen 11
				ÖREBRO  -  70227
				SE

B0-C5-CA   (hex)		shanghai University Ding-Tech software Corp.,ltd
400000-4FFFFF     (base 16)		shanghai University Ding-Tech software Corp.,ltd
				No.9 Lane3,CaoDong Feeder Rd, Xuhui Area,shanghai,China
				shanghai  shanghai  200235
				CN

78-C2-C0   (hex)		Shanghai Hanyi Technologies Co,.Ltd.
C00000-CFFFFF     (base 16)		Shanghai Hanyi Technologies Co,.Ltd.
				Room 2008, Feidiao International Building
				Shanghai  Shanghai  200030
				CN

B4-37-D1   (hex)		NANJING PUTIAN TELECOMMUNICATIONS TECHNOLOGY CO.,LTD.
C00000-CFFFFF     (base 16)		NANJING PUTIAN TELECOMMUNICATIONS TECHNOLOGY CO.,LTD.
				No.1 Putian Road,Yuhuamenwai,Nanjing
				Nan Jing  Jiang Su  210022
				CN

B4-37-D1   (hex)		Nanjing yuekong Intelligent Technology
900000-9FFFFF     (base 16)		Nanjing yuekong Intelligent Technology
				Room 923, No.2 Building, Deying International Square, No.222, Changhon
				Nanjing  Jiangsu  210012
				CN

78-C2-C0   (hex)		Ningbo Sanxing Electric Co., Ltd.
300000-3FFFFF     (base 16)		Ningbo Sanxing Electric Co., Ltd.
				Fengwan No. 17, Cicheng Town,
				Ningbo  Zhejiang  315033
				CN

78-C2-C0   (hex)		RONIX incorporated
200000-2FFFFF     (base 16)		RONIX incorporated
				904, 648, Seobusaet-gil,
				SEOUL  GEUMCHEON-GU  153-803
				KR

74-F8-DB   (hex)		TBM CO., LTD.
C00000-CFFFFF     (base 16)		TBM CO., LTD.
				A-806, 282 Hakeui-Ro
				Anyang-City  Gyeonggi-Do  431-810
				KR

74-F8-DB   (hex)		Bernard Krone Holding GmbH & Co. KG
E00000-EFFFFF     (base 16)		Bernard Krone Holding GmbH & Co. KG
				Heinrich-Krone-Str. 10
				Spelle  Niedersachsen  48480
				DE

B4-37-D1   (hex)		Stratom, Inc.
500000-5FFFFF     (base 16)		Stratom, Inc.
				5375 Western Avenue Suite A
				Boulder  Colorado  80301
				US

B4-37-D1   (hex)		KOMSIS ELEKTRONIK SISTEMLERI SAN. TIC. LTD.STI
400000-4FFFFF     (base 16)		KOMSIS ELEKTRONIK SISTEMLERI SAN. TIC. LTD.STI
				SERIF ALI MAH. TURKER CAD. MIRAS SOK.
				ISTANBUL  UMRANIYE  34775
				TR

B4-37-D1   (hex)		eInfochips Limited
800000-8FFFFF     (base 16)		eInfochips Limited
				303 Parishram Building, 5/B Rashmi Society
				Ahmedabad  Gujarat  380009
				IN

54-9A-11   (hex)		Elite Silicon Technology, Inc.
B00000-BFFFFF     (base 16)		Elite Silicon Technology, Inc.
				5F-B, No.24-2, Idustry E. Road IV.
				Hsinchu  Taiwan  300
				TW

54-9A-11   (hex)		Tite, Inc.
800000-8FFFFF     (base 16)		Tite, Inc.
				11040 Bollinger Canyon Road, Suite E-107
				San Ramon  CA  94582
				US

74-F8-DB   (hex)		Enercon Technologies
000000-0FFFFF     (base 16)		Enercon Technologies
				25 Northbrook Drive
				Gray  ME  04039
				US

88-5D-90   (hex)		Unitac Technology Limited
E00000-EFFFFF     (base 16)		Unitac Technology Limited
				Unit 01, 10/F Carnival Comm. Bldg,
				North Point  -  -
				HK

88-5D-90   (hex)		Shenzhen Speedrun Technologies Co.,Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Speedrun Technologies Co.,Ltd.
				Room 303,Builing 5, GuiYuan Garden, NO.62 Airong Road, SheKou, NanShan District
				ShenZhen  GuangDong  518067
				CN

74-F8-DB   (hex)		Capwave Technologies Inc
B00000-BFFFFF     (base 16)		Capwave Technologies Inc
				1501 Ocean Ave
				Asbury Park  NJ  07712
				US

88-5D-90   (hex)		Creative Sensor Inc.
800000-8FFFFF     (base 16)		Creative Sensor Inc.
				9F., No.501, Sec. 6, Nanjing E. Rd., Neihu Dist., Taipei City 114, Taiwan (R.O.C.)
				Taipei City  Taiwan  114
				TW

88-5D-90   (hex)		DAIDONG Industrial System Co., Ltd.
200000-2FFFFF     (base 16)		DAIDONG Industrial System Co., Ltd.
				153B 3L, Namdong Industrial Complex, 729-2, Gojan-dong
				Incheon  Kyeong-gi  405-822
				KR

80-7B-85   (hex)		EFCO
500000-5FFFFF     (base 16)		EFCO
				10F-3, No.270, SEc 4  Chung Hsiao E Rd
				Taipei    10674
				TW

80-7B-85   (hex)		Zhuhai TOP Intelligence Electric Co., Ltd.
300000-3FFFFF     (base 16)		Zhuhai TOP Intelligence Electric Co., Ltd.
				No.619,Huawei Road
				Zhuhai City  Guangdong Province  519070
				CN

80-7B-85   (hex)		Hangzhou Synway Information Engineering Co., Ltd
100000-1FFFFF     (base 16)		Hangzhou Synway Information Engineering Co., Ltd
				  No.3756 Nanhuan Road,Hangzhou,Zhejiang,P.R.China
				Hangzhou  Zhejiang  310053
				CN

80-7B-85   (hex)		Quantel USA, Inc.
400000-4FFFFF     (base 16)		Quantel USA, Inc.
				601 Haggerty Ln.
				Bozeman  Montana  59715
				US

54-9A-11   (hex)		Alfen BV
900000-9FFFFF     (base 16)		Alfen BV
				Hefbrugweg
				Almere  Netherlands  1332AP
				NL

54-9A-11   (hex)		Torrap Design Limited
200000-2FFFFF     (base 16)		Torrap Design Limited
				Unit 6, 19 Gloucester Road
				Hurstville  New South Wales  2220
				AU

64-FB-81   (hex)		Securosys SA
700000-7FFFFF     (base 16)		Securosys SA
				Technopark 1
				Zürich  ZH  8005
				CH

1C-CA-E3   (hex)		TengFeng
500000-5FFFFF     (base 16)		TengFeng
				3F, 1st Bldg, Yuejun Zhenxing lnd. Park,
				Shenzhen  Guangdong  518000
				CN

80-E4-DA   (hex)		Guangzhou Pinzhong Electronic Technology CO., LTD
100000-1FFFFF     (base 16)		Guangzhou Pinzhong Electronic Technology CO., LTD
				Room 810, Yinglong Plaza
				Guangzhou  Guangdong  510000
				CN

80-E4-DA   (hex)		Thurlby Thandar Instruments LTD
200000-2FFFFF     (base 16)		Thurlby Thandar Instruments LTD
				Glebe Road
				Huntingdon  Cambridgeshire  PE29 7DR
				GB

1C-CA-E3   (hex)		SIREA
A00000-AFFFFF     (base 16)		SIREA
				69 Rue de L'industrie
				CASTRES  Midi-Pyrénée  81100
				FR

2C-D1-41   (hex)		PIN SHANG LED Co., LTD.
C00000-CFFFFF     (base 16)		PIN SHANG LED Co., LTD.
				5-6Floor, Huilongda Industrial Park,shuitian community, ShiYan Town,bao’an district,
				ShenZhen  Guangdong  518108
				CN

2C-D1-41   (hex)		Shanghai RW ELE&TEC CO.,LTD
400000-4FFFFF     (base 16)		Shanghai RW ELE&TEC CO.,LTD
				10th Floor, No 6, Lane 2500 Xiupu Road, Pudong New District, Shanghai
				Shanghai  Shanghai  201315
				CN

90-C6-82   (hex)		PowerShield Limited
D00000-DFFFFF     (base 16)		PowerShield Limited
				12 Target Court
				Glenfield  Auckland  0627
				NZ

2C-6A-6F   (hex)		Holjeron
D00000-DFFFFF     (base 16)		Holjeron
				9524 SW Tualatin Sherwood Rd.
				Tualatin  OR  97062
				US

2C-6A-6F   (hex)		Sensity Systems
C00000-CFFFFF     (base 16)		Sensity Systems
				480 Oakmead Parkway
				Sunnyvale  California  94085
				US

90-C6-82   (hex)		Neone, Inc.
400000-4FFFFF     (base 16)		Neone, Inc.
				2001 Travis Heights Blvd
				Austin  Texas  78704
				

98-02-D8   (hex)		Navroom Beijing, China
900000-9FFFFF     (base 16)		Navroom Beijing, China
				Floor 22, Suite B, Xi'Ao Center, Datun Road
				Beijing    100101
				CN

98-02-D8   (hex)		HySecurity
A00000-AFFFFF     (base 16)		HySecurity
				6623 South 228th Street
				Kent  WA  98032
				US

98-02-D8   (hex)		Ormazabal Protection&Automation
700000-7FFFFF     (base 16)		Ormazabal Protection&Automation
				B/Basauntz, 2
				Igorre  Bizkaia  48140
				ES

A0-BB-3E   (hex)		Beijing Techshino Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Beijing Techshino Technology Co., Ltd.
				8/F, Building No. 1, Huihuang International Plaza, Shangdi 10th Street, Haidian District,
				Beijing  Beijing  100085
				CN

98-02-D8   (hex)		Promicon Elektronik GmbH + Co.KG
D00000-DFFFFF     (base 16)		Promicon Elektronik GmbH + Co.KG
				Im Michelreis 6
				Pliezhausen  Baden-Württemberg  72124
				DE

98-02-D8   (hex)		HANSHIN MEDICAL CO., LTD.
B00000-BFFFFF     (base 16)		HANSHIN MEDICAL CO., LTD.
				166, Pyeongcheonro, Bupyeong-gu
				Incheon  Incheon  403-853
				KR

98-02-D8   (hex)		Stoerk-Tronic, Stoerk GmbH & Co.KG
000000-0FFFFF     (base 16)		Stoerk-Tronic, Stoerk GmbH & Co.KG
				Untere Waldplätze 6
				Stuttgart  Baden-Wuerttemberg  70569
				DE

2C-6A-6F   (hex)		TINYCO
400000-4FFFFF     (base 16)		TINYCO
				3rd Fl., Dukwon Bldg., 1225-4 Gaepo-Dong
				Seoul  Gangnam-Ku  135-963
				KR

2C-6A-6F   (hex)		Beep, Inc.
600000-6FFFFF     (base 16)		Beep, Inc.
				2519 Mission St
				SAN FRANCISCO  CA  94110
				US

2C-6A-6F   (hex)		Cloudproject Generation Srl
300000-3FFFFF     (base 16)		Cloudproject Generation Srl
				Via Melchiorre Gioia 82
				MILANO  MI  20125
				IT

A0-BB-3E   (hex)		SIMTEC Elektronik GmbH
700000-7FFFFF     (base 16)		SIMTEC Elektronik GmbH
				Glonner Strasse 5
				Feldkirchen-Westerham  Bayern  83620
				DE

28-FD-80   (hex)		Millcode
000000-0FFFFF     (base 16)		Millcode
				Bergsgårdsliden 5
				Halmstad  Halland  30272
				SE

2C-26-5F   (hex)		Itus Networks, LLC
800000-8FFFFF     (base 16)		Itus Networks, LLC
				6319 Nepo Drive
				San Jose  CALIFORNIA  95119
				US

2C-26-5F   (hex)		Coremate Technical Co., Ltd
700000-7FFFFF     (base 16)		Coremate Technical Co., Ltd
				7F., No576, Sec.1, Minsheng N. Rd.,
				Taoyuan    33393
				TW

2C-26-5F   (hex)		GTA Electronics Co., Ltd.
400000-4FFFFF     (base 16)		GTA Electronics Co., Ltd.
				9F., No.788, Zhongzheng Rd., Zhonghe Dist.
				New Taipei City    23586
				TW

2C-26-5F   (hex)		Griessbach
100000-1FFFFF     (base 16)		Griessbach
				Im Biotechnologiepark
				Luckenwalde    14943
				DE

28-FD-80   (hex)		Galileo, Inc.
100000-1FFFFF     (base 16)		Galileo, Inc.
				5-3-29 Tokiwagi
				Ueda  Nagano  386-0027
				JP

A0-BB-3E   (hex)		Link Labs
000000-0FFFFF     (base 16)		Link Labs
				130 Holiday Court, Suite 100
				Annapolis  Maryland  21401
				US

28-FD-80   (hex)		Grandway Technology (Shenzhen) Limited
D00000-DFFFFF     (base 16)		Grandway Technology (Shenzhen) Limited
				Block 7, Zhu Keng Industrial Zone
				Ping Shan District  Shenzhen  518118
				CN

28-FD-80   (hex)		University of York
700000-7FFFFF     (base 16)		University of York
				York Neuroimaging Centre, The Biocentre
				York  Yorkshire  YO10 5NY
				GB

F8-02-78   (hex)		Luxul Technology Inc
A00000-AFFFFF     (base 16)		Luxul Technology Inc
				2F., No.3, Yuandong Rd
				New Taipei City  Taiwan  220
				TW

0C-EF-AF   (hex)		Rotel
900000-9FFFFF     (base 16)		Rotel
				43-59 Queens Road East
				Wanchai  Hong Kong  00000
				HK

0C-EF-AF   (hex)		Firmware Design AS
600000-6FFFFF     (base 16)		Firmware Design AS
				Grannes Terrasse 45
				Hafrsfjord  Rogaland  N-4044
				NO

F8-02-78   (hex)		Reason Tecnologia SA
100000-1FFFFF     (base 16)		Reason Tecnologia SA
				 Rua Joaquim Carneiro, 192
				Florianópolis  Santa Catarina  8811120
				BR

F8-02-78   (hex)		Dueton Systems s.r.o.
D00000-DFFFFF     (base 16)		Dueton Systems s.r.o.
				Varsavska 290/13
				Prague 2  Vinohrady  120 00
				CZ

A4-4F-29   (hex)		LUCEOR
200000-2FFFFF     (base 16)		LUCEOR
				2 Place Jules Gevelot
				ISSY LES MOULINEAUX  IDF  92138
				FR

A4-4F-29   (hex)		Olssen B.V.
100000-1FFFFF     (base 16)		Olssen B.V.
				Schrank 9
				Hardinxveld-Giessendam  Zuid-Hollland  3371KJ
				NL

A4-4F-29   (hex)		DGC Access AB
400000-4FFFFF     (base 16)		DGC Access AB
				Sveavägen 145
				Stockholm  Stockholms Län  113 46
				SE

A4-4F-29   (hex)		Selektro Power Inc
600000-6FFFFF     (base 16)		Selektro Power Inc
				3610 NW 115th Ave
				Doral  Florida  33178
				US

A4-4F-29   (hex)		Shanghai KuanYu Industrial Network Equipment Co.,Ltd
500000-5FFFFF     (base 16)		Shanghai KuanYu Industrial Network Equipment Co.,Ltd
				15/F,No.3003,Baoyang Road, Baoshan District,
				  Shanghai  201901
				CN

3C-39-E7   (hex)		chipsguide technology Co.,LTD
B00000-BFFFFF     (base 16)		chipsguide technology Co.,LTD
				NanGuang road, DongHua design house 758 room
				Shenzhen  Guangdong  518000
				CN

3C-39-E7   (hex)		ELSA Japan Inc.
300000-3FFFFF     (base 16)		ELSA Japan Inc.
				Mita UT Bldg., 3-42-10 Shiba,
				Minato-ku,  Tokyo  105-0014
				JP

0C-EF-AF   (hex)		Engineering Center ENERGOSERVICE
300000-3FFFFF     (base 16)		Engineering Center ENERGOSERVICE
				Kotlasskaya 26
				Arkhangelsk  Arkhangelsk region  163046
				RU

10-07-23   (hex)		Beijing Assem Technology Co., ltd
100000-1FFFFF     (base 16)		Beijing Assem Technology Co., ltd
				Floor 6, Jinglong International Plaza,
				Chaoyang District  Beijing  100107
				CN

D0-22-12   (hex)		GNS-GmbH
A00000-AFFFFF     (base 16)		GNS-GmbH
				Adenauerstr. 18
				Wuerselen  NRW  52146
				DE

D0-22-12   (hex)		Xperio Labs Ltd.
C00000-CFFFFF     (base 16)		Xperio Labs Ltd.
				Unit 3709, 37th Floor, Tower II,
				Hong Kong  Hong Kong  HONG KONG
				HK

10-07-23   (hex)		ESTONE TECHNOLOGY INC
600000-6FFFFF     (base 16)		ESTONE TECHNOLOGY INC
				21015 Commerce Point Drive Walnut, CA 91789
				Los Angeles  California  91789
				US

E8-18-63   (hex)		DongGuan Pengxun Electronics Technology Co., Ltd.
300000-3FFFFF     (base 16)		DongGuan Pengxun Electronics Technology Co., Ltd.
				10th floor, Jinhui Bussiness Building,
				DongGuan City  GuangDong Province  523850
				CN

E8-18-63   (hex)		Guangzhou Tianyi Electronics Co., Ltd
400000-4FFFFF     (base 16)		Guangzhou Tianyi Electronics Co., Ltd
				A3, Hongtu Industrial Plot, Dashi town,
				 Guangzhou  Guangdong,  511430,
				CN

B8-D8-12   (hex)		ZheJiang FangTai Electirc Co., Ltd
E00000-EFFFFF     (base 16)		ZheJiang FangTai Electirc Co., Ltd
				B11 Block, Science and Technology Park
				Hangzhou  ZheJiang  310024
				CN

E8-18-63   (hex)		DigiMagus Technology (Shenzhen) Co., Ltd
000000-0FFFFF     (base 16)		DigiMagus Technology (Shenzhen) Co., Ltd
				1206, Shenzhen University-town Business Park, Lishan Road
				ShenZhen  GuangDong  518055
				CN

74-E1-4A   (hex)		aritec gmbh
800000-8FFFFF     (base 16)		aritec gmbh
				Vorstadtgasse 15
				Maienfeld  Outside U.S./Canada  7304
				CH

B8-D8-12   (hex)		iModesty Technology Corp.
300000-3FFFFF     (base 16)		iModesty Technology Corp.
				3F-1, No.76, Sec.2 Jiafeng S.Rd.,
				Zhubei County  Taiwan  302
				TW

E8-18-63   (hex)		JDM Mobile Internet Solution(Shanghai) Co., Ltd.
A00000-AFFFFF     (base 16)		JDM Mobile Internet Solution(Shanghai) Co., Ltd.
				2F, Building D, BenQ Plaza, No.207
				Shanghai  Shanghai  200335
				CN

B8-D8-12   (hex)		Entotem LTD
900000-9FFFFF     (base 16)		Entotem LTD
				Unit 3, South Stanmore Stables,
				Newbury  Berks  RG20 8SR
				GB

B8-D8-12   (hex)		XIAMEN XINDECO LTD.
500000-5FFFFF     (base 16)		XIAMEN XINDECO LTD.
				5F.,XINXI BLDG.,HULI
				Xiamen  Fujian  361000
				CN

74-E1-4A   (hex)		AStar Design Service Technologies Co., Ltd.
A00000-AFFFFF     (base 16)		AStar Design Service Technologies Co., Ltd.
				3F, No219-1, Jianguo Rd. Sindian Dist.
				New Taipei City  Taiwan  23142
				TW

E8-18-63   (hex)		ARTECH SOLUTION CO.,LTD
600000-6FFFFF     (base 16)		ARTECH SOLUTION CO.,LTD
				470/11 Pattanakarn Rd.,Suanluang，Bkk.10250 Thailand
				Bangkok  Bangkok  10250
				TH

BC-66-41   (hex)		Shenzhen Crave Communication Co.,ltd
C00000-CFFFFF     (base 16)		Shenzhen Crave Communication Co.,ltd
				8th Block, Dongfangming Industry Park
				Shenzhen  GuangDong  518000
				CN

BC-66-41   (hex)		Lucent Trans Electronics Co., Ltd
E00000-EFFFFF     (base 16)		Lucent Trans Electronics Co., Ltd
				9F-1, NO.16, CHIEN PAH RD.,
				NEW TAIPEI CITY    23511
				TW

E4-95-6E   (hex)		eZeLink LLC
900000-9FFFFF     (base 16)		eZeLink LLC
				Office 1104, Aspect Tower, Executive Towers, Business Bay
				Dubai  Dubai  111581
				AE

BC-66-41   (hex)		VSN Mobil
700000-7FFFFF     (base 16)		VSN Mobil
				1975 E. Sunrise Blbvd., #400
				Fort Lauderdale  Florida  33304
				US

58-FC-DB   (hex)		SWARCO TRAFFIC SYSTEMS GMBH
B00000-BFFFFF     (base 16)		SWARCO TRAFFIC SYSTEMS GMBH
				Kelterstr. 67
				Unterensingen  Baden-Württemberg  72669
				DE

B0-1F-81   (hex)		TAIWAN Anjie Electronics Co.,Ltd.
D00000-DFFFFF     (base 16)		TAIWAN Anjie Electronics Co.,Ltd.
				One 7th Floor,No.125,Lane 235, Pao Chiao Xindian District
				New Taipei City  Xindian District  231
				TW

BC-66-41   (hex)		Sidus Novum Sp. z o. o.
B00000-BFFFFF     (base 16)		Sidus Novum Sp. z o. o.
				Ul. Ogrodowa 3B/203
				Zielona Góra  Lubuskie  65462
				PL

58-FC-DB   (hex)		Xmodus Systems GmbH
A00000-AFFFFF     (base 16)		Xmodus Systems GmbH
				Reiherstrasse 2
				Haiger  Hessen  35708
				DE

B0-1F-81   (hex)		SHENZHEN GRID TECHNOLOGY CO.,LTD
500000-5FFFFF     (base 16)		SHENZHEN GRID TECHNOLOGY CO.,LTD
				6thfloor,jinda Technology Center,No.8 of kefeng Road ,Science and Technology Park,NanshanDist,Shenzhen
				shenzhen  guangdong  518054
				CN

B0-1F-81   (hex)		Private
200000-2FFFFF     (base 16)		Private

F4-0E-11   (hex)		Shenzhen Grandsun Electronic Co.,Ltd.
700000-7FFFFF     (base 16)		Shenzhen Grandsun Electronic Co.,Ltd.
				Gaoqiao Industrial Zone,Baishitang Village,
				Shenzhen  Guangdong  518116
				CN

F4-0E-11   (hex)		Elektronika Naglic d.o.o.
E00000-EFFFFF     (base 16)		Elektronika Naglic d.o.o.
				Goricica pri Ihanu 44
				Domzale    1230
				SI

F4-0E-11   (hex)		NIHON MEGA LOGIC CO.,LTD.
C00000-CFFFFF     (base 16)		NIHON MEGA LOGIC CO.,LTD.
				Mitsui-Seimei-Kameido BLDG. 1F
				Koutou-ku  Tokyo  136-0071
				JP

B0-1F-81   (hex)		Sound United
300000-3FFFFF     (base 16)		Sound United
				11433 Cronridge Drive
				Owings Mills  Maryland  21117
				US

F4-0E-11   (hex)		E-SONG
500000-5FFFFF     (base 16)		E-SONG
				BUSAN TECHNOPARK Head office & Factory: Unit 102
				Busan  N/A  618-230
				KR

F4-0E-11   (hex)		Shenzhen headsun technology
300000-3FFFFF     (base 16)		Shenzhen headsun technology
				3 Floor, C Building, NanYuan Industrial
				ShenZhen  GuangDong  518000
				CN

14-1F-BA   (hex)		Swiss Electronic (Shenzhen) Co., Ltd
C00000-CFFFFF     (base 16)		Swiss Electronic (Shenzhen) Co., Ltd
				2712 Great China International Exchange Square
				Shenzhen  Guangdong  518026
				CN

14-1F-BA   (hex)		Shenzhen CATIC Information Technology Industry Co.,Ltd
800000-8FFFFF     (base 16)		Shenzhen CATIC Information Technology Industry Co.,Ltd
				3/FL, Block 1, Shenzhen Software Park, No.2, Gaoxin Middle Street,Nanshan
				Shen Zhen  Guang Dong  518057
				CN

14-1F-BA   (hex)		Winsonic Electronics Co., Ltd.
A00000-AFFFFF     (base 16)		Winsonic Electronics Co., Ltd.
				No. 290-1, Wen Chung Rd.,
				Taoyuan City    330
				TW

14-1F-BA   (hex)		GloQuad
100000-1FFFFF     (base 16)		GloQuad
				301 Biz Incubation Center, GSBC
				Suwon-si  Gyeonggi-do  443-270
				KR

BC-34-00   (hex)		Parlay Labs dba Highfive
C00000-CFFFFF     (base 16)		Parlay Labs dba Highfive
				471 Emerson St.
				Palo Alto  California  94301
				US

7C-70-BC   (hex)		XD-GE Automation CO.,LTD
100000-1FFFFF     (base 16)		XD-GE Automation CO.,LTD
				101# Fengcheng 6 Road
				Xi'an  ShanXi  710016
				CN

A4-3B-FA   (hex)		ALSTOM Strongwish (Shenzhen) Co., Ltd
B00000-BFFFFF     (base 16)		ALSTOM Strongwish (Shenzhen) Co., Ltd
				5F, Building No.6, Keji Middle 2 Road, High-Tech Industrial Park
				Shenzhen  Guangdong  518057
				CN

A4-3B-FA   (hex)		The Magstim Company Ltd.
E00000-EFFFFF     (base 16)		The Magstim Company Ltd.
				Spring Gardens
				Whitland  Carmarthenshire  SA34 0HR
				GB

BC-34-00   (hex)		IPLINK Technology Corp
100000-1FFFFF     (base 16)		IPLINK Technology Corp
				8F-5, No. 347, Jingsin St.
				New Taipei City    23582
				TW

A4-3B-FA   (hex)		Plus One Japan Ltd.
A00000-AFFFFF     (base 16)		Plus One Japan Ltd.
				Storia Akasaka 410,
				Minato-ku  Tokyo  1080052
				JP

A4-3B-FA   (hex)		SHANGHAI XIETONG TECHNOLOGY INC.
C00000-CFFFFF     (base 16)		SHANGHAI XIETONG TECHNOLOGY INC.
				423 Wuning Road,Shanghai
				  Shanghai  200063
				CN

D0-76-50   (hex)		DAIKEN AUTOMACAO LTDA
100000-1FFFFF     (base 16)		DAIKEN AUTOMACAO LTDA
				 AVENIDA SAO GABRIEL,481
				COLOMBO  PARANA  83404000
				BR

D0-76-50   (hex)		PelKorea
B00000-BFFFFF     (base 16)		PelKorea
				60, Haan-ro
				Gwangmyeong-si  Gyeonggi-do  KS009
				KR

D0-76-50   (hex)		InventDesign
A00000-AFFFFF     (base 16)		InventDesign
				Valschermkade 29
				Amsterdam  Noord-Holland  1059CD
				NL

A4-3B-FA   (hex)		Powell Industries
200000-2FFFFF     (base 16)		Powell Industries
				201-55 Gostick Place
				North Vancouver  British Columbia  V7M 3N2
				

D0-76-50   (hex)		ENCORED Technologies, Inc.
700000-7FFFFF     (base 16)		ENCORED Technologies, Inc.
				8F KTS, 215 Bongeunsa-ro
				  Seoul  135-831
				KR

74-19-F8   (hex)		Trend-tech Technology Co., Limited
100000-1FFFFF     (base 16)		Trend-tech Technology Co., Limited
				NO. 609, Noble Plaza, Qianjin YiLu
				Shenzhen  Guangdong  518101
				CN

74-19-F8   (hex)		Cloudvue Technologies Corporation
400000-4FFFFF     (base 16)		Cloudvue Technologies Corporation
				830 Stewart Drive, Suite 115
				Sunnyvale  CA  94085
				US

74-19-F8   (hex)		Essential Trading Systems Corp
300000-3FFFFF     (base 16)		Essential Trading Systems Corp
				9 Austin Drive
				Marlborough  CT  06447
				US

4C-4B-F9   (hex)		Shenzhen HommPro Technology Co.,Ltd
200000-2FFFFF     (base 16)		Shenzhen HommPro Technology Co.,Ltd
				5F,Building B,Zhengchangda Digital Technology Park,Jian'an Road,Tangwei community,Fuhai street,Bao'an District
				Shenzhen  GuangDong  518000
				CN

40-11-75   (hex)		Beijing Hexinruitong Electric Power Technology Co., Ltd.
300000-3FFFFF     (base 16)		Beijing Hexinruitong Electric Power Technology Co., Ltd.
				Room 306, 3F, No.16, Shangdi 5 Street, Haidian District
				Beijing  Beijing  100085
				CN

40-11-75   (hex)		Guangzhou RALID Information System Co.Ltd
700000-7FFFFF     (base 16)		Guangzhou RALID Information System Co.Ltd
				ROOM 201 at 2nd floor in 2nd Building,No.602, Guangshan 2nd Road, Tianhe District
				Guangzhou  Guangdong  510663
				CN

40-11-75   (hex)		NanJing HuaStart Network Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		NanJing HuaStart Network Technology Co.,Ltd.
				Room 568,Longmian Road,Jiangning District
				Nanjing   Jiang Su  210000
				CN

40-11-75   (hex)		Chongqing IQIYI Intelligence Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Chongqing IQIYI Intelligence Technology Co., Ltd.
				Yongli International Center, Sanlitun, Chaoyang District
				Beijing  Beijing  100027
				CN

10-DC-B6   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

10-DC-B6   (hex)		Shenzhen Sunwoda intelligent hardware Co.,Ltd
E00000-EFFFFF     (base 16)		Shenzhen Sunwoda intelligent hardware Co.,Ltd
				No.6-6,Yan Shan Rd.,Baoan District,Shenzhen City,China
				Shenzhen  Guangdong  518105
				CN

10-DC-B6   (hex)		Prolan Zrt.
600000-6FFFFF     (base 16)		Prolan Zrt.
				Szentendrei út 1-3.
				Budakalasz    2011
				HU

54-A4-93   (hex)		Shenzhen C & D Electronics Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

10-DC-B6   (hex)		Sanofi (Beijing) Pharmaceutical Co., Ltd.
800000-8FFFFF     (base 16)		Sanofi (Beijing) Pharmaceutical Co., Ltd.
				No.7, Xingsheng Street, Beijing Economic and Technological Development Zone
				Beijing  Beijing  100176
				CN

10-DC-B6   (hex)		CAL-COMP INDUSTRIA E COMERCIO DE ELETRONICOS E INFORMATICA LTDA
200000-2FFFFF     (base 16)		CAL-COMP INDUSTRIA E COMERCIO DE ELETRONICOS E INFORMATICA LTDA
				AVENIDA TORQUATO TAPAJOS, 7503 TARUMA GALPAO 2 - CNPJ: 07.200.194/0003-80
				MANAUS  AMAZONAS  69041-025
				BR

54-A4-93   (hex)		ShenZhen Smart&Aspiration Co.,LTD
100000-1FFFFF     (base 16)		ShenZhen Smart&Aspiration Co.,LTD
				Guanlan
				ShenZhen  GuangDong  518000
				CN

54-A4-93   (hex)		Chengdu EVECCA Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Chengdu EVECCA Technology Co.,Ltd.
				Floor 20, Building B, Xingchen International, No.555, Middle Section of Yizhou Avenue
				Chengdu  Sichuan  610015
				CN

54-A4-93   (hex)		AUSOUNDS INTELLIGENCE, LLC
500000-5FFFFF     (base 16)		AUSOUNDS INTELLIGENCE, LLC
				929 108TH AVE NE STE 1200, BELLEVUE, WA, 98004-4787, UNITED STATES
				BELLEVUE  WA  98004
				US

54-A4-93   (hex)		ASSEM TECHNOLOGY CO.,LTD.
D00000-DFFFFF     (base 16)		ASSEM TECHNOLOGY CO.,LTD.
				No. 17, Minquan St., Tucheng Dist.,
				New Taipei City  Taiwan (R.O.C.)  236
				TW

04-D1-6E   (hex)		Elotec Fischer Elektronik GmbH
D00000-DFFFFF     (base 16)		Elotec Fischer Elektronik GmbH
				Nordgaustraße 20
				Furth im Wald  Bavaria  93437
				DE

54-A4-93   (hex)		Nederman Holding AB
E00000-EFFFFF     (base 16)		Nederman Holding AB
				Sydhamnsgatan 2
				Helsingborg  Sweden  252 28
				SE

44-03-77   (hex)		OMNISENSE SYSTEMS PRIVATE LIMITED TAIWAN BRANCH
D00000-DFFFFF     (base 16)		OMNISENSE SYSTEMS PRIVATE LIMITED TAIWAN BRANCH
				7th Floor, No. 10, Lane 30, Lane 358, Ruiguang Road, Neihu District, Taipei, Taiwan
				Taipei    114
				TW

50-62-55   (hex)		Ufanet SC
000000-0FFFFF     (base 16)		Ufanet SC
				bldg 4/3, Prospect Octyabrya
				Ufa    450001
				RU

64-31-39   (hex)		Dongguan Huili electroacoustic Industrial Co.,ltd
700000-7FFFFF     (base 16)		Dongguan Huili electroacoustic Industrial Co.,ltd
				Dalang Town, Biyun Cai Bai Cun East Second Street 66,A4 Building 501
				Dongguan  Guangdong  523770
				CN

50-62-55   (hex)		Southern Ground Audio LLC
900000-9FFFFF     (base 16)		Southern Ground Audio LLC
				101 Gardner Park
				Peachtree City  GA  30269
				US

C4-95-4D   (hex)		Shenzhen Xtooltech Co., Ltd
900000-9FFFFF     (base 16)		Shenzhen Xtooltech Co., Ltd
				10574 Acacia St, Suite D4
				Rancho Cucamonga  CA  91730
				US

C4-95-4D   (hex)		Shen Zhen Euse Technology Co.,Ltd
200000-2FFFFF     (base 16)		Shen Zhen Euse Technology Co.,Ltd
				4/F, Block A2, Xinhao First Industrial Zone,  Qiaotou Community, Fuhai Street
				Shenzhen  Guangdong  518103
				CN

A0-22-4E   (hex)		ProPhotonix
300000-3FFFFF     (base 16)		ProPhotonix
				3020 Euro Business Park
				Co Cork  Little Island  n/A
				IE

A0-22-4E   (hex)		Applied Information, Inc.
700000-7FFFFF     (base 16)		Applied Information, Inc.
				4411 Suwanee Dam Rd, Suite 510
				Suwanee  GA  30024
				US

20-0A-0D   (hex)		Netinovo Technologies(Shenzhen) Ltd
200000-2FFFFF     (base 16)		Netinovo Technologies(Shenzhen) Ltd
				101,201,301,Bldg8,No.1 industry zone,Shanmen Community,Yanluo Street
				Shenzhen  Guangdong  518105
				CN

20-0A-0D   (hex)		bcheck NV
800000-8FFFFF     (base 16)		bcheck NV
				Livornostraat 66/12
				Brussels  Brussels  1000
				BE

40-2C-76   (hex)		Suteng Innovation Technology Co., Ltd.
800000-8FFFFF     (base 16)		Suteng Innovation Technology Co., Ltd.
				10-11/F, Block 3, Chongwen Garden, Nanshan IPark, 3370 Liuxian Avenue, Nanshan District
				Shenzhen    518000
				CN

40-2C-76   (hex)		Lista AG
000000-0FFFFF     (base 16)		Lista AG
				Fabrikstrasse 1
				Erlen  TG  8586
				CH

40-2C-76   (hex)		Zhejiang Guoli Security Technology Co., Ltd.
700000-7FFFFF     (base 16)		Zhejiang Guoli Security Technology Co., Ltd.
				Room (1-1-178), No. 150, Zhangpu Road, Jiushigang Town, Haishu District
				Ningbo  Zhejiang  315000
				CN

40-2C-76   (hex)		Annapurna labs
900000-9FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

50-DE-19   (hex)		BRAINWARE TERAHERTA INFORMATION TECHNOLOGY CO.,LTD.
B00000-BFFFFF     (base 16)		BRAINWARE TERAHERTA INFORMATION TECHNOLOGY CO.,LTD.
				F3 and F4 of Innovation Industrial Park Phase II in Hefei High-tech Zone
				Hefei   Anhui   230000
				CN

40-2C-76   (hex)		Guangzhou LANGO Electronics Technology Co., Ltd.
600000-6FFFFF     (base 16)		Guangzhou LANGO Electronics Technology Co., Ltd.
				136#, Gaopu Road, Tianhe District
				Guangzhou  Guangdong  510663
				CN

50-DE-19   (hex)		Penny & Giles Aerospace Ltd
D00000-DFFFFF     (base 16)		Penny & Giles Aerospace Ltd
				15 Enterprise Way
				Christchurch  Dorset  BH23 6HH
				GB

50-DE-19   (hex)		Bliq B.V.
500000-5FFFFF     (base 16)		Bliq B.V.
				Hogeweyselaan 145
				Weesp    1382JK
				NL

3C-FA-D3   (hex)		AMobile Solutions (Xiamen) CO. , LTD.
D00000-DFFFFF     (base 16)		AMobile Solutions (Xiamen) CO. , LTD.
				Room 105A, building 5#, No. 20-24 East Huoju  Road,  Huoju Park, Xiamen Torch Hi-tech zone
				Xiamen    361006
				CN

3C-FA-D3   (hex)		Energous Corporation
800000-8FFFFF     (base 16)		Energous Corporation
				3590 N. First Street
				San Jose  CA  95134
				US

3C-FA-D3   (hex)		Gulf Security Technology Co., Ltd
500000-5FFFFF     (base 16)		Gulf Security Technology Co., Ltd
				80 Changjiang East Road, Economic & Technology Development Zone
				Qinhuangdao  Hebei  066000
				CN

3C-FA-D3   (hex)		Home Control AS
000000-0FFFFF     (base 16)		Home Control AS
				Postboks 1618 Vika
				Oslo    0119 
				NO

B0-B3-53   (hex)		HANMECIPS CO.
900000-9FFFFF     (base 16)		HANMECIPS CO.
				17, Alphacity 1-ro 31-gil, Suseong-gu, Daegu, Republic of Korea
				TAEGU  TAEGU/053  ASIKRKS002TAEGU
				KR

B0-B3-53   (hex)		Zenlayer
500000-5FFFFF     (base 16)		Zenlayer
				21680 GATEWAY CENTER DR., Suite#350
				DIAMOND BAR  CA  91765
				US

90-E2-FC   (hex)		ShenZhen Temwey Innovation Technology Co.,Ltd.
200000-2FFFFF     (base 16)		ShenZhen Temwey Innovation Technology Co.,Ltd.
				Room 1008, 10/F, Bld.B, Bantian International Centre, No. 5 South Huancheng Road, Bantian Street of Shenzhen Longgang District
				SHENZHEN  GUANGDONG  518129
				CN

90-E2-FC   (hex)		Beijing Lanxum Computer Technology CO.,LTD.
D00000-DFFFFF     (base 16)		Beijing Lanxum Computer Technology CO.,LTD.
				3A Floor,BlockB,Technology Fortune Center,No 8 Xueqing Road,Haidian District,
				Beijing  Beijing  100192
				CN

90-E2-FC   (hex)		Dongguan Kangyong electronics technology Co. Ltd
400000-4FFFFF     (base 16)		Dongguan Kangyong electronics technology Co. Ltd
				No 9,Yincheng 1st Road, Xiabian Village, Chang’an Town
				Dongguan  GuangDong  523877
				CN

90-E2-FC   (hex)		bitsensing Inc.
800000-8FFFFF     (base 16)		bitsensing Inc.
				165, Yeoksam-ro,
				Gangnam-gu, Seoul,  Republic of Korea  06247
				KR

90-E2-FC   (hex)		Stanley Security
C00000-CFFFFF     (base 16)		Stanley Security
				8350 Sunlight Drive
				Fishers  IN  46037
				US

14-AE-85   (hex)		iSolution Technologies Co.,Ltd.
D00000-DFFFFF     (base 16)		iSolution Technologies Co.,Ltd.
				5F,Bldg #6, Zhongguan Honghualing Industrial South Park
				Shenzhen  Guangdong  518055
				CN

7C-BC-84   (hex)		VANTAGE INTEGRATED SECURITY SOLUTIONS PVT LTD
D00000-DFFFFF     (base 16)		VANTAGE INTEGRATED SECURITY SOLUTIONS PVT LTD
				B3, Bredon House, 321, Tettenhall Road, Tettenhall
				Wolverhampton  West Midlands  WV6 0JZ
				GB

64-62-66   (hex)		Pass & Seymour, Inc d/b/a Legrand
600000-6FFFFF     (base 16)		Pass & Seymour, Inc d/b/a Legrand
				50 Boyd Ave
				Syracuse  NY  13209
				US

64-62-66   (hex)		FaceHeart Inc.
300000-3FFFFF     (base 16)		FaceHeart Inc.
				Rm. 8, 19F., No.118, Ciyun Rd., East Dist.
				Hsinchu  Taiwan  300
				TW

64-62-66   (hex)		Sensoro Co., Ltd.
A00000-AFFFFF     (base 16)		Sensoro Co., Ltd.
				7F D-Block, Lei Shing Hong Center, No. 8 Guangshun South Street, Chaoyang District,
				Beijing  Beijing  100102
				CN

94-CC-04   (hex)		Shandong free optical technology co., ltd.
B00000-BFFFFF     (base 16)		Shandong free optical technology co., ltd.
				195 East First Street, Industrial First Street, Economic Development Zone, Weifang, Weicheng District,
				Weifeng  Shandong  216000
				CN

94-CC-04   (hex)		ENTEC Electric & Electronic Co., LTD.
900000-9FFFFF     (base 16)		ENTEC Electric & Electronic Co., LTD.
				78-2 Buncheon-ri, Bongdam-eup
				Hwaseong-city  Gyungki-do  445-894
				KR

94-CC-04   (hex)		SynchronicIT BV
E00000-EFFFFF     (base 16)		SynchronicIT BV
				Spoorstraat 155, room 413
				Gennep  Nederland  6591 GT
				NL

F4-90-CB   (hex)		Simavita (Aust) Pty Ltd
D00000-DFFFFF     (base 16)		Simavita (Aust) Pty Ltd
				Suite 2.02, L2, 54 Miller Street
				North Sydney  NSW  2060
				AU

F4-90-CB   (hex)		Ricker Lyman Robotic
300000-3FFFFF     (base 16)		Ricker Lyman Robotic
				319 Main Street
				Beacon  NY  12508
				US

F4-90-CB   (hex)		Beijing Penslink Co., Ltd.
800000-8FFFFF     (base 16)		Beijing Penslink Co., Ltd.
				502,12rd floor,no.2,Fangheng International Center Beijing, Chaoyang district 100102
				Beijing  Beijing  100102
				CN

F4-90-CB   (hex)		Private
A00000-AFFFFF     (base 16)		Private

C0-9B-F4   (hex)		The Professional Monitor Company Ltd
D00000-DFFFFF     (base 16)		The Professional Monitor Company Ltd
				Holme Court A1
				Biggleswade  Bedfordshire  SG189ST
				GB

C0-9B-F4   (hex)		Connected Space Management
100000-1FFFFF     (base 16)		Connected Space Management
				62 boulevard Diderot
				Paris    75012
				FR

C0-9B-F4   (hex)		Inveo
A00000-AFFFFF     (base 16)		Inveo
				Rzemieslnicza 21
				Kozy    43-340
				PL

94-FB-A7   (hex)		Beijing Leja Tech co., Ltd.
200000-2FFFFF     (base 16)		Beijing Leja Tech co., Ltd.
				5F-Building1, Longyu center East Tower,Longyu Middle street, Changping District
				Beijing  Beijing  100000
				CN

94-FB-A7   (hex)		Skyring Smart Technologies(Shenzhen) Co., Ltd.
E00000-EFFFFF     (base 16)		Skyring Smart Technologies(Shenzhen) Co., Ltd.
				6F GDC Building, 9Gaoxin Centeral Avenue 3rd, Nanshan District
				Shenzhen  Guangdong  518057
				CN

94-FB-A7   (hex)		Inaxsys Security Systems inc.
100000-1FFFFF     (base 16)		Inaxsys Security Systems inc.
				11685 Philippe-Panneton
				Montreal  Quebec  H1E 4M1
				CA

94-FB-A7   (hex)		ELKRON 
A00000-AFFFFF     (base 16)		ELKRON 
				Via Bologna 188/C
				TURIN  ITALY  10154
				IT

38-F7-CD   (hex)		ARUNAS PTY LTD
700000-7FFFFF     (base 16)		ARUNAS PTY LTD
				Freedom Taxation Building, 1 Ransley St
				PENRITH  NSW  2750
				AU

38-F7-CD   (hex)		Macherey-Nagel GmbH & Co. KG
D00000-DFFFFF     (base 16)		Macherey-Nagel GmbH & Co. KG
				Neumann-Neander-Str. 6-8
				Düren  Deutschland  52355
				DE

38-F7-CD   (hex)		Polska Fabryka Wodomierzy i Ciep?omierzy FILA 
000000-0FFFFF     (base 16)		Polska Fabryka Wodomierzy i Ciep?omierzy FILA 
				?eromskiego 30
				Sztum  POMORSKIE  82-400
				PL

70-69-79   (hex)		Liquid Instruments Pty Ltd
B00000-BFFFFF     (base 16)		Liquid Instruments Pty Ltd
				243 Northbourne Avenue
				Lynham  ACT  2602
				AU

70-69-79   (hex)		An Phat Information Technology Co., Ltd
800000-8FFFFF     (base 16)		An Phat Information Technology Co., Ltd
				3C Tran Phu, Ward 4, District 5
				Ho Chi Minh City    70000
				VN

70-69-79   (hex)		Ibyte
500000-5FFFFF     (base 16)		Ibyte
				Rua Cleia, 460
				Fortaleza  Ceara  60863280
				BR

70-69-79   (hex)		BAS-IP LP
E00000-EFFFFF     (base 16)		BAS-IP LP
				Suite 1, 4 Queen Street
				Edinburgh    EH2 1JE
				GB

70-69-79   (hex)		Full Solution Telecom
000000-0FFFFF     (base 16)		Full Solution Telecom
				Calle 130A #59C-42, Barrio Ciudad Jardin Norte
				Bogota  Distrito Capital de Bogota  111111
				CO

CC-C2-61   (hex)		Tecnoideal Srl
200000-2FFFFF     (base 16)		Tecnoideal Srl
				Via Lea Cazzuoli nr.43
				Mirandola  Modena  41037
				IT

CC-C2-61   (hex)		Shenzhen Uyesee Technology Co.,Ltd
A00000-AFFFFF     (base 16)		Shenzhen Uyesee Technology Co.,Ltd
				201C, C6 Building, HengFeng Industry Park Hezhou, Baoan District
				shenzhen  Guangdong  518102
				CN

CC-C2-61   (hex)		Toong In Electronic Corp.
E00000-EFFFFF     (base 16)		Toong In Electronic Corp.
				10F-8, No.738, Chung Cheng Road, Chung Ho Dist,.
				New Taipei City  Taiwan  235
				TW

30-49-50   (hex)		Shenzhen iTG robot Co.,Ltd.
700000-7FFFFF     (base 16)		Shenzhen iTG robot Co.,Ltd.
				3rd Floor, 5th Floor, No. 5, Elephant Factory Building, Baiyunshan New Village, Tongsheng Community, Dalang Street, Longhua District
				Shenzhen    518109
				CN

30-49-50   (hex)		ADVANCED MICROWAVE ENGINEERING SRL
400000-4FFFFF     (base 16)		ADVANCED MICROWAVE ENGINEERING SRL
				VIA LUCCA 50/54
				FIRENZE    50142
				IT

30-49-50   (hex)		Morgan Schaffer Inc.
300000-3FFFFF     (base 16)		Morgan Schaffer Inc.
				8300 rue St-Patrick bureau 150
				LaSalle  Quebec  H8N 2H1
				CA

D0-14-11   (hex)		Evoco Labs CO., LTD
200000-2FFFFF     (base 16)		Evoco Labs CO., LTD
				Room 315, Building 1, No.58 Xiangke Rd, Pudong New Area
				Shanghai  Shanghai  201203
				CN

D0-14-11   (hex)		Shen Zhen HaiHe Hi-Tech Co., Ltd
C00000-CFFFFF     (base 16)		Shen Zhen HaiHe Hi-Tech Co., Ltd
				Bldg 10,Fumin Industrial Zone,Pinghu Subdistrict,Longgang District
				Shen Zhen  Guang Dong  518111
				CN

D0-14-11   (hex)		EkkoSense Ltd
000000-0FFFFF     (base 16)		EkkoSense Ltd
				Sir Colin Campbell Building, UNIP
				Triumph Road, Nottingham  UK Mainland  NG7 2TU
				GB

D0-14-11   (hex)		Private
100000-1FFFFF     (base 16)		Private

5C-85-7E   (hex)		Nautech Electronics Ltd
D00000-DFFFFF     (base 16)		Nautech Electronics Ltd
				120 Cryers Road
				East Tamaki  Auckland  2013
				NZ

5C-85-7E   (hex)		Cable Matters Inc.
300000-3FFFFF     (base 16)		Cable Matters Inc.
				153 Northboro Road, Suite 5
				Southborough  MA  01772
				US

30-49-50   (hex)		IK Elektronik GmbH
500000-5FFFFF     (base 16)		IK Elektronik GmbH
				Friedrichsgruener Str. 11-13
				Muldenhammer    08262
				DE

5C-85-7E   (hex)		Beijing HZFD Technology Co., Ltd
700000-7FFFFF     (base 16)		Beijing HZFD Technology Co., Ltd
				Room 502, Tower A, Fangyuan Building, No. 56, South Zhongguancun Street, Haidian District
				Beijing  Beiijng  100044
				CN

5C-85-7E   (hex)		Sichuan C.H Control Technology Co., Ltd.
100000-1FFFFF     (base 16)		Sichuan C.H Control Technology Co., Ltd.
				4F,B8,Tianfu Software Park, No. 99, Tianhua 1st Road
				Chengdu  Si chuan  610000
				CN

F4-69-D5   (hex)		Junchuang (Xiamen) Automation Technology Co.,Ltd
100000-1FFFFF     (base 16)		Junchuang (Xiamen) Automation Technology Co.,Ltd
				Room 705, building a, No. 96, Xiangxing Road, industrial zone, Xiamen Torch High tech Zone
				Xiamen   Fujian  361101
				CN

5C-85-7E   (hex)		Zhejiang Jetron Ark Digital Technology Co., Ltd
A00000-AFFFFF     (base 16)		Zhejiang Jetron Ark Digital Technology Co., Ltd
				Room 12-9, building B (Hongmao building), No. 338, Juxing West Road, Jiangbei District, Ningbo, ZheJiang, China
				Ningbo    315000
				CN

F4-69-D5   (hex)		ITS Co., Ltd. 
300000-3FFFFF     (base 16)		ITS Co., Ltd. 
				Wooyang building 7F, 68, Wolpyeong-ro, Nam-gu, Ulsan, Republic of Korea
				Ulsan    44690
				KR

4C-93-A6   (hex)		Wuhan Maiwe communication Co.,Ltd
C00000-CFFFFF     (base 16)		Wuhan Maiwe communication Co.,Ltd
				Building 2,Area E, Phase ii, Optical valley core center, No.52, Liufang road, East Lake Hi-tech Development Zone,Wuhan,China
				Wuhan  Hubei  430000
				CN

4C-93-A6   (hex)		Cantronic Systems (Canada) Inc
D00000-DFFFFF     (base 16)		Cantronic Systems (Canada) Inc
				Unit 8, 62 Fawcett
				Coquitlam  British Columbia  V3K 6V5
				CA

4C-93-A6   (hex)		Atrie Technology Fzc
100000-1FFFFF     (base 16)		Atrie Technology Fzc
				ELOB office no E-44F-41, Hamriya Free zone
				Sharjah  Sharjah  10001
				AE

28-B7-7C   (hex)		Anser Coding Inc.
900000-9FFFFF     (base 16)		Anser Coding Inc.
				34F., No. 99, Sec. 1, XinTai 5th Rd., Xizhi Dist.,
				New Taipei City    221
				TW

28-B7-7C   (hex)		Ray Pte Ltd
E00000-EFFFFF     (base 16)		Ray Pte Ltd
				Suite #09-01, 20 Collyer Quay, 
				Singapore    049319
				SG

98-FC-84   (hex)		Guangdong DE at science and technology co., LTD
800000-8FFFFF     (base 16)		Guangdong DE at science and technology co., LTD
				Taide Technology Park,Jinfenghuang Industrial District, Fenggang Town,
				Dongguan  GuangDong  523000
				CN

C8-63-14   (hex)		Tymphany Acoustic Technology (Huizhou) Co.,  Ltd.
200000-2FFFFF     (base 16)		Tymphany Acoustic Technology (Huizhou) Co.,  Ltd.
				Tymphany Industrial Area, Xin Lian Village, XinXu Town, HuiYang District
				Huizhou  Guangdong  516223
				CN

98-FC-84   (hex)		chiconypower
B00000-BFFFFF     (base 16)		chiconypower
				23F, No.69, Sec. 2, Guangfu Rd., Sanchong Dist., New Taipei City 241, Taiwan (R.O.C.)
				New Taipei  Taiwan  241
				TW

18-FD-CB   (hex)		Cabtronix AG
200000-2FFFFF     (base 16)		Cabtronix AG
				Hohstrass 1
				Kloten  Zuerich  8302
				CH

58-20-8A   (hex)		SAMBO HITECH
D00000-DFFFFF     (base 16)		SAMBO HITECH
				469,Seokjung-ro,Namdong-Gu
				Incheon    21501
				KR

18-FD-CB   (hex)		Accel Robotics
500000-5FFFFF     (base 16)		Accel Robotics
				9160 KEARNY VILLA CT
				San Diego  CA  92123
				US

58-20-8A   (hex)		Conductix-Wampfler
A00000-AFFFFF     (base 16)		Conductix-Wampfler
				10102 Fst
				omaha  NE  68127
				US

58-20-8A   (hex)		Infodev Electronic Designers Intl.
B00000-BFFFFF     (base 16)		Infodev Electronic Designers Intl.
				1995 rue Frank-Carrel Suite 202
				Quebec  Quebec  G1N4H9
				CA

58-20-8A   (hex)		JIA HUANG JHAN YE CO.,LTD
500000-5FFFFF     (base 16)		JIA HUANG JHAN YE CO.,LTD
				1F., No. 19, Huanmei 2nd St., Donggang Township
				Plngtung County    928
				TW

CC-4F-5C   (hex)		MatchX GmbH
200000-2FFFFF     (base 16)		MatchX GmbH
				Adalbert Str.8
				Berlin    10999
				DE

FC-CD-2F   (hex)		SCOPUS INTERNATIONAL-BELGIUM
A00000-AFFFFF     (base 16)		SCOPUS INTERNATIONAL-BELGIUM
				Cable Centre, Raja International Building, 
				Andamukkam, Kollam  Kerala  691 001
				IN

FC-CD-2F   (hex)		Spedos ADS a.s.
C00000-CFFFFF     (base 16)		Spedos ADS a.s.
				Hranická771
				Valašské Mezi?í?í    75701
				CZ

58-95-D8   (hex)		Epiphan Systems Inc
700000-7FFFFF     (base 16)		Epiphan Systems Inc
				400 March Rd Suite 510
				Ottawa  Ontario  K2K3H4
				CA

58-95-D8   (hex)		SuZhou Ruishengwei Intelligent Technology Co.,Ltd
B00000-BFFFFF     (base 16)		SuZhou Ruishengwei Intelligent Technology Co.,Ltd
				Room 507?Building 1?ZhongXuXin Science Park?NO.91?Weixin Road?Suzhou Industrial Park
				SuZhou  JiangSu  215021
				CN

58-95-D8   (hex)		Alunos AG
D00000-DFFFFF     (base 16)		Alunos AG
				Zugerstrasse
				Unteraegeri    6314
				CH

20-85-93   (hex)		Mastodon Design
900000-9FFFFF     (base 16)		Mastodon Design
				176 Anderson Ave, Suite F112
				Rochester  NY  14607
				US

DC-4A-9E   (hex)		Dongguan Huili electroacoustic Industrial Co.,ltd
000000-0FFFFF     (base 16)		Dongguan Huili electroacoustic Industrial Co.,ltd
				Dalang Town, Biyun Cai Bai Cun East Second Street 66,A4 Building 501
				Dongguan  Guangdong  523770
				CN

84-11-C2   (hex)		Beijing Dayu Technology Co., Ltd.
100000-1FFFFF     (base 16)		Beijing Dayu Technology Co., Ltd.
				11B-660, Building 13, Wangjing Xiyuan, Chaoyang
				Beijing    100000
				CN

84-11-C2   (hex)		C TECH BILISIM TEKNOLOJILERI SAN. VE TIC. A.S.
900000-9FFFFF     (base 16)		C TECH BILISIM TEKNOLOJILERI SAN. VE TIC. A.S.
				Teknopark ?stanbul, TGB, Sanayi Mah. Teknopark Bulvar?, No:1, Blok:1 Kat:2, Kurtköy-Pendik 34912, ?STANBUL
				Istanbul    34912
				TR

84-11-C2   (hex)		Guangdong Creator&Flyaudio Electronic Technology Co.,LTD
B00000-BFFFFF     (base 16)		Guangdong Creator&Flyaudio Electronic Technology Co.,LTD
				Block D1, No.3 Industrial Zone, Banxianshan, Hengli Town
				Dongguan  Guangdong  523460
				CN

84-11-C2   (hex)		Dangerous Music Group, LLC
E00000-EFFFFF     (base 16)		Dangerous Music Group, LLC
				701 South Mountain Road
				New City  NY  10956
				US

8C-47-6E   (hex)		Private
700000-7FFFFF     (base 16)		Private

8C-AE-49   (hex)		BERTIN TECHNOLOGIES
300000-3FFFFF     (base 16)		BERTIN TECHNOLOGIES
				10 Avenue Ampère
				Montigny-le-Bretonneux  IDF  78180
				FR

8C-AE-49   (hex)		Gati Information Technolog(Kunshan)Co.,Ltd.
500000-5FFFFF     (base 16)		Gati Information Technolog(Kunshan)Co.,Ltd.
				2-5 / F, room 7, No. 88, Baifu Road, Economic and Technological Development Zone
				Kunshan.  jiangsu  215300
				CN

8C-AE-49   (hex)		SEVERIN Elektrogeräte GmbH
200000-2FFFFF     (base 16)		SEVERIN Elektrogeräte GmbH
				Röhre 27
				Sundern  NRW  59846
				DE

A4-53-EE   (hex)		SOS LAB Co., Ltd.
C00000-CFFFFF     (base 16)		SOS LAB Co., Ltd.
				B-101, BI Center, GIST 123 Cheomdangwagi-ro
				Gwangju    61005
				KR

A4-53-EE   (hex)		Williamson Corporation
400000-4FFFFF     (base 16)		Williamson Corporation
				70 Domino Drive
				Concord  MA  01742
				US

A4-53-EE   (hex)		Larva.io OÜ
300000-3FFFFF     (base 16)		Larva.io OÜ
				Sidur 3
				Tallinn    11313
				EE

A4-53-EE   (hex)		Foshan Yisihang Electrical Technology Co., Ltd.
500000-5FFFFF     (base 16)		Foshan Yisihang Electrical Technology Co., Ltd.
				F4 Block A Lege Industrial Park, North Yucheng Road, Lunjiao Town, Shunde District
				Foshan  Guangdong  528308
				CN

A0-02-4A   (hex)		IoTecha Corp
E00000-EFFFFF     (base 16)		IoTecha Corp
				2555 Route 130, Suite 2
				Cranbury  NJ  08512
				US

78-D4-F1   (hex)		TNB
C00000-CFFFFF     (base 16)		TNB
				Ryazanskiy Prospekt, 24, k.2
				Moscow    109428
				RU

78-D4-F1   (hex)		Burisch Elektronik Bauteile GmbH
000000-0FFFFF     (base 16)		Burisch Elektronik Bauteile GmbH
				Leopoldauerstrasse 29
				Vienna    1210
				AT

78-D4-F1   (hex)		Guangzhou Kingray information technology Co.,Ltd.
600000-6FFFFF     (base 16)		Guangzhou Kingray information technology Co.,Ltd.
				No.8, Jinghu Road, Huadu Reg
				Guangzhou    510800
				CN

78-D4-F1   (hex)		Ekoenergetyka - Polska S.A.
300000-3FFFFF     (base 16)		Ekoenergetyka - Polska S.A.
				ul. Nowy Kisielin - Wysockiego 8
				Zielona Gora    66-002
				PL

44-6F-D8   (hex)		Shenzhen Furuilian Electronic Co.,Ltd.
100000-1FFFFF     (base 16)		Shenzhen Furuilian Electronic Co.,Ltd.
				3/F, No.5 Building Workshop, No.123, Shuitian Industrial Zone,Baoshi East Road, Shuitian Community, Shiyan Street, Bao'an District,
				Shenzhen    518000
				CN

44-6F-D8   (hex)		lb Lautsprecher gmbH
400000-4FFFFF     (base 16)		lb Lautsprecher gmbH
				Steinerstrasse 15 K
				Munich  Bavaria  81369
				DE

44-6F-D8   (hex)		Beijing gpthink technology co.,LTD.
B00000-BFFFFF     (base 16)		Beijing gpthink technology co.,LTD.
				Beijing fengtai guogongzhuang
				Beijing    100070
				CN

44-6F-D8   (hex)		Global Telecom Engineering, Inc
800000-8FFFFF     (base 16)		Global Telecom Engineering, Inc
				17901 Von Karman Ave, Suite 600
				Irvine  CA  92614
				US

40-11-75   (hex)		disguise Technologies Limited
C00000-CFFFFF     (base 16)		disguise Technologies Limited
				88-89 Blackfriars Rd
				London  South Bank  SE1 8HA,
				GB

74-F8-DB   (hex)		Avantree Corporation
900000-9FFFFF     (base 16)		Avantree Corporation
				175 Bernal road Ste 106
				SAN JOSE  CA  95119-1343
				US

04-11-19   (hex)		Shenzhen YIZHENG Technology Co.,Ltd
800000-8FFFFF     (base 16)		Shenzhen YIZHENG Technology Co.,Ltd
				2305, block A7, Chuangzhi Yuncheng, Liuxian Avenue, Xili Town, Nanshan District
				ShenZhen  GuangDong  518000
				CN

04-11-19   (hex)		Hubei Baobao Intelligent Technology Co.,LTD
B00000-BFFFFF     (base 16)		Hubei Baobao Intelligent Technology Co.,LTD
				Hubei Baobao Intelligent Technology Co.,LTD
				Wuhan  Hubei  430000
				CN

04-11-19   (hex)		JULIDA LIMITED
E00000-EFFFFF     (base 16)		JULIDA LIMITED
				1F., NO. 137, DATONG ST., BEITOU DIST.
				TAIPEI CITY  Taiwan  112
				TW

04-11-19   (hex)		FORT Robotics Inc.
000000-0FFFFF     (base 16)		FORT Robotics Inc.
				170 S. Independence Mall, Suite 275W
				Philadelphia  PA  19106
				US

E8-6C-C7   (hex)		Hangzhou Lanxum Security Technology Co., Ltd
900000-9FFFFF     (base 16)		Hangzhou Lanxum Security Technology Co., Ltd
				Room 402, Block A, 4th Floor, Building 3, No. 351 changhe Road, Changhe Street, Binjiang District
				Hangzhou  Zhejiang  310000
				CN

E8-6C-C7   (hex)		KLAB
600000-6FFFFF     (base 16)		KLAB
				94-23,Techno 2-ro
				Yuseong-gu  Daejeon  34014
				KR

24-5D-FC   (hex)		Senix Corporation
C00000-CFFFFF     (base 16)		Senix Corporation
				10516 Route 116, Suite 300
				Hinesburg  VT  05461
				US

24-5D-FC   (hex)		Hunan Honestone lntelligence Technology Co.,Ltd
D00000-DFFFFF     (base 16)		Hunan Honestone lntelligence Technology Co.,Ltd
				705, Building 1, Fortune Plaza, Wankuntu, Xiangzhang Road, Yuhua District, Changsha City,
				Changsha    410007
				CN

E8-6C-C7   (hex)		Shenzhen Rongda Computer Co.,Ltd
500000-5FFFFF     (base 16)		Shenzhen Rongda Computer Co.,Ltd
				905, Block B, DuoCaiKeChuan Park, No.5 Guanle Road
				Longhua District  Shenzhen, Guangdong    518110
				CN

00-55-DA   (hex)		Nanoleaf
500000-5FFFFF     (base 16)		Nanoleaf
				100 Front Street East, 4th Floor
				Toronto  Ontario  M5A 1E1
				CA

24-5D-FC   (hex)		Dodge
E00000-EFFFFF     (base 16)		Dodge
				6040 Ponders Court
				Greenville  SC  29615
				US

60-15-92   (hex)		EDA Technology Co.,LTD
200000-2FFFFF     (base 16)		EDA Technology Co.,LTD
				Room 301, Building 24, Shengchuang Enterprise Park,No.1661 Jialuo Road, Jiading District
				Shanghai  Shanghai  201822
				CN

60-15-92   (hex)		insensiv GmbH
A00000-AFFFFF     (base 16)		insensiv GmbH
				Auf dem Esch 28
				Bielefeld  Nordrhein-Westfalen  33619
				DE

60-15-92   (hex)		REMOWIRELESS COMMUNICATION INTERNATIONAL CO.,LIMITED
D00000-DFFFFF     (base 16)		REMOWIRELESS COMMUNICATION INTERNATIONAL CO.,LIMITED
				 REMOWIRELESS RM1111,HONGYI BUILDING NO.2158 WANYUAN ROAD
				SHANGHAI  SHANGHAI  201103
				CN

0C-5C-B5   (hex)		avxav Electronic Trading LLC
100000-1FFFFF     (base 16)		avxav Electronic Trading LLC
				Office 534 Building # 6WA Dubai Airport Free Zone
				Dubai  United Arab Emirates  33964
				AE

0C-5C-B5   (hex)		Munters Europe AB
E00000-EFFFFF     (base 16)		Munters Europe AB
				Borgarfjordsgatan 16
				Kista    16440
				SE

0C-5C-B5   (hex)		HongKong Blossom Limited
200000-2FFFFF     (base 16)		HongKong Blossom Limited
				B1715,Jiansheng Building,No. 1 Pingji Road, NanWan Street Longgang
				Shenzhen    518112
				CN

1C-A0-EF   (hex)		Sequent AG
300000-3FFFFF     (base 16)		Sequent AG
				Eptingerstrasse 3
				Basel    4052
				CH

0C-5C-B5   (hex)		Yamasei
000000-0FFFFF     (base 16)		Yamasei
				2F., No. 37, Ln. 11, Sec. 6, Minquan E. Rd., Neihu Dist.
				Taipei  Taiwan (R.O.C.)  114
				TW

1C-A0-EF   (hex)		tec5AG
700000-7FFFFF     (base 16)		tec5AG
				Weisskirchener Strasse 2-6
				Steinbach  Hessen  61449
				DE

20-CE-2A   (hex)		MeshPlusPlus, Inc.
A00000-AFFFFF     (base 16)		MeshPlusPlus, Inc.
				935 W. Chestnut St., Suite #505
				Chicago  IL  60642
				US

20-CE-2A   (hex)		LAUDA DR R WOBSER GMBH & CO KG
D00000-DFFFFF     (base 16)		LAUDA DR R WOBSER GMBH & CO KG
				Pfarrstrasse 41/43
				Lauda-Koenigshofen    97922
				DE

20-CE-2A   (hex)		Rugged Monitoring
900000-9FFFFF     (base 16)		Rugged Monitoring
				1415 Frank-Carrel, Suite 230
				Quebec City  Quebec  G1N4N7
				CA

20-CE-2A   (hex)		Zaber Technologies Inc.
500000-5FFFFF     (base 16)		Zaber Technologies Inc.
				#2 - 605 West Kent Ave. N.
				Vancouver  B.C.  V6P 6T7
				CA

20-CE-2A   (hex)		Swarovski Optik KG
B00000-BFFFFF     (base 16)		Swarovski Optik KG
				Daniel Swarovski Street 70
				Absam    6067
				AT

88-C9-B3   (hex)		Brabender Technologie GmbH & Co, KG
500000-5FFFFF     (base 16)		Brabender Technologie GmbH & Co, KG
				Kulturstrasse 49
				Duisburg    47055
				DE

20-CE-2A   (hex)		Funkwerk Systems GmbH
E00000-EFFFFF     (base 16)		Funkwerk Systems GmbH
				Im Funkwerk 5
				Koelleda    99625
				DE

88-C9-B3   (hex)		Hasbro Inc
400000-4FFFFF     (base 16)		Hasbro Inc
				1027 Newport Ave
				Pawtucket  RI  02861
				US

88-C9-B3   (hex)		Sercomm Corporation.
E00000-EFFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

88-C9-B3   (hex)		Divelbiss Corporation
800000-8FFFFF     (base 16)		Divelbiss Corporation
				9778 Mount Gilead Road
				Fredericktown  OH  43019
				US

88-C9-B3   (hex)		Origins Technology Limited
D00000-DFFFFF     (base 16)		Origins Technology Limited
				18 Xinzhong St Dushiyangguang4-1106, Dongcheng
				Beijing    100027
				CN

C8-F5-D6   (hex)		Shanghai Mo xiang Network Technology CO.,Ltd
900000-9FFFFF     (base 16)		Shanghai Mo xiang Network Technology CO.,Ltd
				Room#418-421, ShaHeXiLi, 2-2 XiLi North Road, LiCheng Community, Xili Street, NanShan District
				Shenzhen  Guangdong  518071
				CN

C8-F5-D6   (hex)		United Barcode Systems
B00000-BFFFFF     (base 16)		United Barcode Systems
				Av. Progres 56, Pol. Ind. els Garrofers
				Vilassar de Mar  Barcelona  08340
				ES

C8-F5-D6   (hex)		Eltako GmbH
C00000-CFFFFF     (base 16)		Eltako GmbH
				Hofener Straße 54
				Fellbach  BW  70736
				DE

C0-FB-F9   (hex)		SHENZHEN ELSKY TECHNOLOGY CO., LTD
C00000-CFFFFF     (base 16)		SHENZHEN ELSKY TECHNOLOGY CO., LTD
				1F BUILDING 2# ASIA INDUSTIAL PARK BANTIAN STREET LONGGANG DISTRICT 
				SHENZHEN  GUANGDONG  518000
				CN

C0-FB-F9   (hex)		Dropbeats Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Dropbeats Technology Co., Ltd.
				Room 304, Building 4?Juli Road ? Pudong New District
				Shanghai  Shanghai  201203
				CN

D0-9F-D9   (hex)		Elevoc Technology Co., Ltd.
600000-6FFFFF     (base 16)		Elevoc Technology Co., Ltd.
				5/F,Unit B,Block12,ShenZhenwan Science and Technology Ecological Garden,Nanshan Dist.
				Shenzhen  Guangdong  518000
				CN

D0-9F-D9   (hex)		Eurolan Ltd
A00000-AFFFFF     (base 16)		Eurolan Ltd
				jk. Drujba 1, ul. 5028, do bl. 15
				Sofia  Sofia (stolitsa)  1592
				BG

E0-5A-9F   (hex)		Fujian Newland Auto-ID Tech. Co,.Ltd.
800000-8FFFFF     (base 16)		Fujian Newland Auto-ID Tech. Co,.Ltd.
				Newland Science & Technology Park, No.1 Rujiang West Rd,Mawei,Fuzhou, P.R.China
				Fuzhou  Fujian  350015
				CN

18-74-E2   (hex)		NextGen RF Design, Inc.
C00000-CFFFFF     (base 16)		NextGen RF Design, Inc.
				2130 Howard Dr W
				North Mankato  MN  56003
				US

18-74-E2   (hex)		Sartorius Lab Instruments GmbH & Co. KG
100000-1FFFFF     (base 16)		Sartorius Lab Instruments GmbH & Co. KG
				Otto-Brenner-Straße 20
				Goettingen    37079
				DE

18-74-E2   (hex)		Linux Automation GmbH
A00000-AFFFFF     (base 16)		Linux Automation GmbH
				Steuerwalder Str 21
				Hildesheim    31137
				DE

E8-78-29   (hex)		Bernd Walter Computer Technology
D00000-DFFFFF     (base 16)		Bernd Walter Computer Technology
				Fontanestr. 18
				Moers  NRW  47445
				DE

18-74-E2   (hex)		Samriddi Automations Pvt. Ltd.
D00000-DFFFFF     (base 16)		Samriddi Automations Pvt. Ltd.
				F-365
				Noida  up  201307
				IN

E8-78-29   (hex)		METZ CONNECT GmbH
A00000-AFFFFF     (base 16)		METZ CONNECT GmbH
				Im Tal 2
				Blumberg    78176
				DE

E8-78-29   (hex)		Shenzhen Jointelli Technologies Co.,Ltd 
100000-1FFFFF     (base 16)		Shenzhen Jointelli Technologies Co.,Ltd 
				Room A4-1203, Building A, Kexing Science Park, No. 15, Keyuan Road,Keyuan Community,Yuehai Street,Nanshan District
				Shenzhen  Guangdong  518000
				CN

E8-78-29   (hex)		Solos Technology Limited
E00000-EFFFFF     (base 16)		Solos Technology Limited
				Unit 211, 2/F., Photonics Centre, No 2 Science Park East Avenue, Shatin
				Hong Kong  Hong Kong  999077
				HK

78-13-05   (hex)		Shenzhen AV-Display Co.,Ltd
800000-8FFFFF     (base 16)		Shenzhen AV-Display Co.,Ltd
				No.39,He Ao Jin Yuan Road, Yuanshan Subdistrict, Longgang District ,Shenzhen, China
				SHENZHEN    518000
				CN

78-13-05   (hex)		Bithouse Oy
B00000-BFFFFF     (base 16)		Bithouse Oy
				Hepolamminkatu 32
				Tampere    FI-33720
				FI

78-13-05   (hex)		CRRC Nangjing Puzhen Haitai Brake Equipment Co., LTD 
600000-6FFFFF     (base 16)		CRRC Nangjing Puzhen Haitai Brake Equipment Co., LTD 
				No.10 Xinglong Road Pukou Economic Development District
				Nanjing  Jiangsu  211800
				CN

A8-5B-36   (hex)		Bluesoo Tech (HongKong) Co.,Limited
000000-0FFFFF     (base 16)		Bluesoo Tech (HongKong) Co.,Limited
				Room 05, 28 / F, good view business centre, 2-16 Garden Street, Mong Kok, Kowloon, Hongkong.
				HongKong    999077
				HK

A8-5B-36   (hex)		DAP B.V.
600000-6FFFFF     (base 16)		DAP B.V.
				Tussendiepen 4a
				Drachten    9206 AD
				NL

A8-5B-36   (hex)		Louis Vuitton Malletier
700000-7FFFFF     (base 16)		Louis Vuitton Malletier
				2 rue du Pont Neuf
				Paris    75001
				FR

A8-5B-36   (hex)		ORBITVU Sp. z o. o.
E00000-EFFFFF     (base 16)		ORBITVU Sp. z o. o.
				Sienkiewicza, 48
				Tarnowskie Góry    42-600
				PL

F0-2A-2B   (hex)		Shenzhen ORVIBO Technology Co., Ltd.
600000-6FFFFF     (base 16)		Shenzhen ORVIBO Technology Co., Ltd.
				F7, Block A7, Nanshan I Park, No.1001 XueYuan Avenue , NanShan District, ShenZhen 518055 PRC.
				shenzhen    518000
				CN

44-A9-2C   (hex)		China Electronics Corporation Greatwall Shengfeifan information system Co.,ltd. Hu'nan computer R.&D. Center
900000-9FFFFF     (base 16)		China Electronics Corporation Greatwall Shengfeifan information system Co.,ltd. Hu'nan computer R.&D. Center
				China Electronics Software Park,Yuelu District,Changsha City,Hunan Province
				Changsha    410013
				CN

44-A9-2C   (hex)		NPP KOMETEH JSC
D00000-DFFFFF     (base 16)		NPP KOMETEH JSC
				Lomanaya 5
				Sankt-Petersburg    196006
				RU

58-48-49   (hex)		Telegaertner Elektronik GmbH
D00000-DFFFFF     (base 16)		Telegaertner Elektronik GmbH
				Hofaeckerstr. 18
				Crailsheim  Baden-Wuerttemberg  74564
				DE

58-48-49   (hex)		STACKFORCE GmbH
800000-8FFFFF     (base 16)		STACKFORCE GmbH
				Biengener Str. 3
				Eschbach    79427
				DE

D0-9F-D9   (hex)		GS Yuasa Infrastructure Systems Co.,Ltd.
300000-3FFFFF     (base 16)		GS Yuasa Infrastructure Systems Co.,Ltd.
				677 Shimoakasaka-Ohnohara
				Kawagoe-Shi  Saitama  350-1155
				JP

58-48-49   (hex)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
400000-4FFFFF     (base 16)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
				NO.8 Tangzhuang Road,Suzhou Industrial Park,Su ZhouCity,JiangSu Province,China
				Suzhou    215021
				CN

58-48-49   (hex)		Haag-Streit AG
C00000-CFFFFF     (base 16)		Haag-Streit AG
				Gartenstadtstrasse 10
				Koeniz    3098
				CH

64-33-B5   (hex)		Revo Smart Technologies co.,limited
500000-5FFFFF     (base 16)		Revo Smart Technologies co.,limited
				RM 1902 EASEY COMM BLDG 253-261 HENNESSY ROAD WANCHAI  HK
				Hong Kong    999077
				CN

28-36-13   (hex)		Shenzhen HQVT TECHNOLOGY Co.,LTD
200000-2FFFFF     (base 16)		Shenzhen HQVT TECHNOLOGY Co.,LTD
				3/F,Building 8 ,Taihua Wutong Island,Xixiang,Bao'an District
				China  Guang Dong  518000
				CN

28-36-13   (hex)		Shandong SIASUN Industrial Software Research Institute Co., Ltd
000000-0FFFFF     (base 16)		Shandong SIASUN Industrial Software Research Institute Co., Ltd
				Rm301,Artificial Intelligence Building,Jingshi Road,Jinan Area Of China(Shandong) Pilot Free Trade Zone
				jinan    250000
				CN

28-36-13   (hex)		ESI Ventures, LLC
600000-6FFFFF     (base 16)		ESI Ventures, LLC
				2085 Humphrey Street
				Fort Wayne  IN  46803
				US

28-36-13   (hex)		AVYCON
D00000-DFFFFF     (base 16)		AVYCON
				16682 Millikan Ave
				Irvine  CA  92606
				US

78-5E-E8   (hex)		Jiangxi guoxuan radio and television technology Co.,Ltd
800000-8FFFFF     (base 16)		Jiangxi guoxuan radio and television technology Co.,Ltd
				No.3 Jincheng First Road, Guzhang Industrial Park, Shicheng County, Ganzhou City, Jiangxi
				Ganzhou     341000
				CN

78-5E-E8   (hex)		Vega-Absolute
200000-2FFFFF     (base 16)		Vega-Absolute
				Kirova 113/1
				Novosibirsk    630008
				RU

78-5E-E8   (hex)		Suzhou Tianping Advanced Digital Technologies Co.Ltd
E00000-EFFFFF     (base 16)		Suzhou Tianping Advanced Digital Technologies Co.Ltd
				Room304,Building 4,No.209.ZhuyuanRoad,Gaoxin District
				Suzhou  Jiangsu  215000
				CN

84-11-C2   (hex)		 FUJIFILM Healthcare Corporation
300000-3FFFFF     (base 16)		 FUJIFILM Healthcare Corporation
				2-1,Shintoyofuta
				Kashiwa-shi  Chiba  277-0804
				JP

78-5E-E8   (hex)		Incontrol LLC
300000-3FFFFF     (base 16)		Incontrol LLC
				23 building 2, office 5-7, Leninskaya Sloboda st
				Moscow    115280
				RU

38-A8-CD   (hex)		NIC Technologii
A00000-AFFFFF     (base 16)		NIC Technologii
				2/5 Selezneva Street
				Krasnodar  Krasnodarsky kray  350059
				RU

38-A8-CD   (hex)		PT Supertone
900000-9FFFFF     (base 16)		PT Supertone
				Jl Gajah Mada 218 F-G
				Jakarta  DKI Jakarta   11120
				ID

50-DE-19   (hex)		DTEN Inc.
E00000-EFFFFF     (base 16)		DTEN Inc.
				97 E Brokaw Rd, Ste 180
				San Jose  CA  95112-1032____
				US

7C-83-34   (hex)		Shenzhen AZW Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Shenzhen AZW Technology Co., Ltd.
				LongJun Industrial Park
				shenzhen    518000
				CN

38-A8-CD   (hex)		Revo Infratech USA Ltd
500000-5FFFFF     (base 16)		Revo Infratech USA Ltd
				7588 Central Parke Blvd Suite# 109
				Mason  OH  45040
				US

7C-83-34   (hex)		Hunan Datang Xianyi Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Hunan Datang Xianyi Technology Co.,Ltd
				No.568 QueYuan Road Chuanggu Park Flat 1001-1061
				Changsha    410000
				CN

7C-83-34   (hex)		ENGINETECH (TIANJIN) COMPUTER CO.,LTD.
A00000-AFFFFF     (base 16)		ENGINETECH (TIANJIN) COMPUTER CO.,LTD.
				No.6 Hechang Road, Wuqing Development Zone
				TIANJIN    301726
				CN

1C-AE-3E   (hex)		P.H.U. Metering Anna Moder
400000-4FFFFF     (base 16)		P.H.U. Metering Anna Moder
				Parkowa 1
				Buczek    98-113
				PL

1C-AE-3E   (hex)		DAO QIN TECHNOLOGY CO.LTD.
000000-0FFFFF     (base 16)		DAO QIN TECHNOLOGY CO.LTD.
				NO.359, ZHONGXIAO RD.
				CHISHANG TOWNSHIP  TAITUNG COUNTY   95861
				TW

7C-83-34   (hex)		Silicon Xpandas Electronics Co., Ltd.
800000-8FFFFF     (base 16)		Silicon Xpandas Electronics Co., Ltd.
				8F., No.437, Ruiguang Rd., Neihu Dist.
				Taipei City 11492    11492
				TW

1C-AE-3E   (hex)		NextDrive Co.
700000-7FFFFF     (base 16)		NextDrive Co.
				8F., No. 8, Ln. 47, Sec. 3, Nangang Rd., Nangang Dist.,
				Taipei City    115004
				TW

98-6E-E8   (hex)		Logos Payment Solutions A/S
A00000-AFFFFF     (base 16)		Logos Payment Solutions A/S
				Nærum Hovedgade 6
				Nærum    2850
				DK

98-6E-E8   (hex)		Blair Companies
600000-6FFFFF     (base 16)		Blair Companies
				5107 Kissell Ave
				Altoona  PA  16601
				US

98-6E-E8   (hex)		First Design System Inc.
E00000-EFFFFF     (base 16)		First Design System Inc.
				Tachibana Shinjuku Bldg. 3F, 3-2-26 Nishi-Shinjuku
				Tokyo  Shinjuku-ku  160-0023
				JP

98-6E-E8   (hex)		Span.IO, Inc.
900000-9FFFFF     (base 16)		Span.IO, Inc.
				679 Bryant Street
				San Francisco  CA  94107
				US

98-6E-E8   (hex)		ReeR SpA
300000-3FFFFF     (base 16)		ReeR SpA
				via carcano 32
				torino    10153
				IT

98-6E-E8   (hex)		Sbarco Technology CO., Ltd.
000000-0FFFFF     (base 16)		Sbarco Technology CO., Ltd.
				4F, No.115, LIde St., JhongHe Dist.
				New Taipei City     23556
				TW

98-80-BB   (hex)		RYEEX Technology Co.,Ltd.
000000-0FFFFF     (base 16)		RYEEX Technology Co.,Ltd.
				RM106,Joinin Hub,Builing J District 71,Construction Industrial Park,Xin'an Street,Bao'an, Shenzhen,China
				SHENZHEN  GUANGDONG  518101
				CN

98-80-BB   (hex)		Neusoft Reach Automotive Technology (Shenyang) Co.,Ltd
600000-6FFFFF     (base 16)		Neusoft Reach Automotive Technology (Shenyang) Co.,Ltd
				No.2 Xinxiu Street, Hunnan District, Shenyang
				Shenyang  Liaoning  110000
				CN

78-72-64   (hex)		digades GmbH
B00000-BFFFFF     (base 16)		digades GmbH
				Äußere Weberstraße 20
				Zittau    02748
				DE

98-80-BB   (hex)		D.Med Technical Products GmbH
E00000-EFFFFF     (base 16)		D.Med Technical Products GmbH
				Klaus-Bungert-Str. 3
				Düsseldorf    40468
				DE

98-80-BB   (hex)		GreatWall Information Co.,Ltd
100000-1FFFFF     (base 16)		GreatWall Information Co.,Ltd
				No.5,3rd EastRoad,ChangshaEconomic and TechnologicalDevelopment Zone,Hunan,Chian
				Changsha  Hunan  410000
				CN

78-72-64   (hex)		Comcast-SRL
C00000-CFFFFF     (base 16)		Comcast-SRL
				Alejo Martinez 17
				Sosua  Puerto Plata  34443
				DO

78-72-64   (hex)		Zhengzhou Reform Intelligent Device Co., Ltd
100000-1FFFFF     (base 16)		Zhengzhou Reform Intelligent Device Co., Ltd
				Kangqiao Business Plaza, Chengdong Road, Zhengbian Road, Guancheng District 2122
				Zhengzhou City  Henan Province  450000
				CN

78-72-64   (hex)		CALTTA TECHNOLOGIES CO.,LTD.
500000-5FFFFF     (base 16)		CALTTA TECHNOLOGIES CO.,LTD.
				Building G2, International E-City, Nanshan District,
				ShenZhen  Guangdong  518052
				CN

78-72-64   (hex)		Heltec Automation
E00000-EFFFFF     (base 16)		Heltec Automation
				64 Chenghong Rd., Longtan Industrial Park, Chenghua District
				Chengdu  Sichuan  610000
				CN

F4-70-0C   (hex)		Shenzhen Excelland Technology Co., Ltd.
100000-1FFFFF     (base 16)		Shenzhen Excelland Technology Co., Ltd.
				5D, Building #1, Tingwei Industrial Park, Liufang Road #6, 67 Zone of Xingdong Community, Xin'an Street, Baoan District
				Shenzhen  Guangdong  518100
				CN

F4-70-0C   (hex)		Changde xsound lnnovation technologies co;ltd.
700000-7FFFFF     (base 16)		Changde xsound lnnovation technologies co;ltd.
				2nd Floor, Building 6, Electroacoustic Industrial Park, Economic Development Zone, Deshan Town, Wuling District
				changde  hunan  415000
				CN

F4-A4-54   (hex)		Shenzhen Cudy Technology Co., Ltd.
800000-8FFFFF     (base 16)		Shenzhen Cudy Technology Co., Ltd.
				Room A606, Gaoxinqi Industrial Park, Baoan 67 Dist
				Baoan 67 District, Shenzhen    518101
				CN

18-45-B3   (hex)		ELPITECH LLC
500000-5FFFFF     (base 16)		ELPITECH LLC
				26 km of Baltya road, business center Riga Lang, office 11.
				Krasnogorsk  Moscow region, Krasnogorsk district  143421
				RU

08-F8-0D   (hex)		Zhejiang Luci Technology Co., Ltd
500000-5FFFFF     (base 16)		Zhejiang Luci Technology Co., Ltd
				14/ F, Building 36, Nantaihu Dongyuan Business Building, High-tech Zone, Wuxing District
				Huzhou  Zhejiang  313000
				CN

08-F8-0D   (hex)		Huizhou changfei Optoelectruonics Technology Co.,Ltd
000000-0FFFFF     (base 16)		Huizhou changfei Optoelectruonics Technology Co.,Ltd
				Floor 3-4.No.26,Xinhua Avenue,Tongqiao town
				Huicheng District,Huizhou City  Guangdong Province  516032
				CN

08-F8-0D   (hex)		HANGZHOU YILI Communication Equipment Ltd
700000-7FFFFF     (base 16)		HANGZHOU YILI Communication Equipment Ltd
				No.12,Kangyuan Road
				Shanghai  Hangzhou  Zhejiang
				CN

1C-A0-D3   (hex)		U-TX Technologies Ltd
700000-7FFFFF     (base 16)		U-TX Technologies Ltd
				Omonoia Avenue
				Limassol  Cyprus  3045
				CY

18-45-B3   (hex)		Sleep Number
E00000-EFFFFF     (base 16)		Sleep Number
				1001 Third Avenue South
				Minneapolis  MN  55404
				US

94-C9-B7   (hex)		Dspread Technology (Beijing) Inc.
D00000-DFFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

94-C9-B7   (hex)		Sitronics JSC
300000-3FFFFF     (base 16)		Sitronics JSC
				Volgogradskiy prospect 32, building 31
				Moscow  Moscow region  109316
				RU

94-C9-B7   (hex)		Realtimes Beijing Technology Co., Ltd.
600000-6FFFFF     (base 16)		Realtimes Beijing Technology Co., Ltd.
				RoomB 901 NO.20 Heping Xiyuan West Heping Street Chaoyang District 
				Beijing    100013
				CN

94-C9-B7   (hex)		Private
800000-8FFFFF     (base 16)		Private

08-F8-0D   (hex)		Shanghai Mininglamp AI Group Co.,Ltd
200000-2FFFFF     (base 16)		Shanghai Mininglamp AI Group Co.,Ltd
				29th,30th,31st and 32nd floors,701 Yunjin Road, Xuhui District
				Shanghai    200232
				CN

08-F8-0D   (hex)		Vont Innovations
B00000-BFFFFF     (base 16)		Vont Innovations
				30 N Gould St Ste R, Sheridan, WY
				Sheridan  WY  82801
				US

08-F8-0D   (hex)		MICKEY INDUSTRY,LTD.
A00000-AFFFFF     (base 16)		MICKEY INDUSTRY,LTD.
				26-3 Higashi 3-Chome 
				Shibuya-ku  Tokyo  150-0011
				JP

94-C9-B7   (hex)		Jinjin Technology (Shenzhen) Co., Ltd
C00000-CFFFFF     (base 16)		Jinjin Technology (Shenzhen) Co., Ltd
				5-4 Shankeng Inner Ring Road, Shanxia Community, Pinghu Street, Longgang District
				Shenzhen  Guangdong  518111
				CN

94-C9-B7   (hex)		MAMMOTHTEK CLOUD(DONG GUAN)TECHNOLOGY CO., LTD
700000-7FFFFF     (base 16)		MAMMOTHTEK CLOUD(DONG GUAN)TECHNOLOGY CO., LTD
				INDUSTRY NORTH ROAD,SONGSHANHU
				DONGGUAN  GUANGDONG  523808
				CN

50-A0-30   (hex)		Shenzhen Hewang Electric Co.,Ltd
700000-7FFFFF     (base 16)		Shenzhen Hewang Electric Co.,Ltd
				5th Floor, building 6, No. 2 Industrial Zone, Guanlong village, Xili town, Nanshan district, 
				Shenzhen    518000
				CN

50-A0-30   (hex)		XEPIC Corporation Limited
100000-1FFFFF     (base 16)		XEPIC Corporation Limited
				Floor 18-19, Shared Spaces, Research and Innovation Park, Huachuang Road, Jiangbei New Area 
				Nanjing  Jiangsu  210043
				CN

04-EE-E8   (hex)		Shanghai ZLAN Information Technology Co.,Ltd
100000-1FFFFF     (base 16)		Shanghai ZLAN Information Technology Co.,Ltd
				28# YuanWen Road, MinHang District
				Shanghai  Shanghai  201199
				CN

50-A0-30   (hex)		Missing-Link Oy
A00000-AFFFFF     (base 16)		Missing-Link Oy
				Åkerlundinkatu 8
				Tampere  Pirkanmaa  33100 
				FI

04-EE-E8   (hex)		Shenzhen C & D Electronics Co., Ltd.
700000-7FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

18-D7-93   (hex)		Autel lntelligent Technology Corp.,Ltd
600000-6FFFFF     (base 16)		Autel lntelligent Technology Corp.,Ltd
				7th, 8th, 10th Floor, Building B1, Zhiyuan Road, No. 1001 Xueyuan Avenue, Xili Street, Nanshan District, Shenzhen
				Shenzhen    518000
				CN

18-D7-93   (hex)		Remote Engineer B.V.
400000-4FFFFF     (base 16)		Remote Engineer B.V.
				It Vegelinskampke, 11
				Akkrum  Select a state (US only)  8491PD
				NL

18-D7-93   (hex)		Private
C00000-CFFFFF     (base 16)		Private

DC-36-43   (hex)		Hangzhou Chingan Tech Co., Ltd.
500000-5FFFFF     (base 16)		Hangzhou Chingan Tech Co., Ltd.
				4F, BLDG. 4, 16# XIYUAN YI ROAD HANGZHOU, ZHEJIANG,CHINA 310030
				hangzhou  zhejiang  310000
				CN

08-26-AE   (hex)		Wuhan Tianyu Information Industry Co., Ltd.
000000-0FFFFF     (base 16)		Wuhan Tianyu Information Industry Co., Ltd.
				Tianyu Building, S.&T.Park, Huazhong University of S.&T.,East Lake Development Zone
				Wuhan  Hubei  430000
				CN

DC-36-43   (hex)		Hefei EA Excelsior Information Security Co., Ltd.
900000-9FFFFF     (base 16)		Hefei EA Excelsior Information Security Co., Ltd.
				1F, Block A, Tsinghua Unis Infoport, Langshan Rd, Hi-Tech Industrial (North), Nanshan
				Shenzhen  Guangdong  518000
				CN

08-26-AE   (hex)		EVTECH SOLUTIONS LTD. DBA 3D-P
700000-7FFFFF     (base 16)		EVTECH SOLUTIONS LTD. DBA 3D-P
				UNIT 101  2609 15TH STREET NE
				CALGARY  Alberta  T2E 8Y4
				CA

98-8F-E0   (hex)		KuaiZhu SmartTechnology?Suzhou?CO.,Ltd
500000-5FFFFF     (base 16)		KuaiZhu SmartTechnology?Suzhou?CO.,Ltd
				NO.209 Zhu Yuan Road
				suzhou  jiangsu  215100
				CN

98-8F-E0   (hex)		Nawon Machinery
900000-9FFFFF     (base 16)		Nawon Machinery
				268, Jaedurumi-gil
				Paju-si  Gyeonggi-do  10863
				KR

98-8F-E0   (hex)		Valinso B.V.
000000-0FFFFF     (base 16)		Valinso B.V.
				Uithof 5
				Wijk en Aalburg    4261 LN
				NL

10-54-D2   (hex)		Shenzhen Dinstech Technology Co.,Ltd.
B00000-BFFFFF     (base 16)		Shenzhen Dinstech Technology Co.,Ltd.
				Shenzhen Qianhai Shenzhen-Hong Kong Cooperation Zone Nanshan Street Linhai Avenue No. 59 Seaside Avenue 3rd Floor D378, Port Building, Shipping Center
				Shenzhen    518000
				CN

10-54-D2   (hex)		Sun wealth technology corporation limited
D00000-DFFFFF     (base 16)		Sun wealth technology corporation limited
				Room605,The Dongfangmingzhu business building,qian jin 1 road,xin an street,bao an district ,shenzhen ,guang dong province,China.
				shenzhen   Guang dong   518000
				CN

10-54-D2   (hex)		ComNav Technology Ltd.
200000-2FFFFF     (base 16)		ComNav Technology Ltd.
				3 floor Building 2,No.618 Chengliu Middle RD. Malu town,
				Shanghai    200000
				CN

10-54-D2   (hex)		Jiangxi Ofilm&Jvneng IoT Tech Co., Ltd.
100000-1FFFFF     (base 16)		Jiangxi Ofilm&Jvneng IoT Tech Co., Ltd.
				Building 2 and 3,Intelligent Technology Industrial Park,high-tech industrial Development Zone, 
				Yingtan     335000
				CN

0C-86-29   (hex)		BADA SYSTEM co., Ltd
200000-2FFFFF     (base 16)		BADA SYSTEM co., Ltd
				Saemalro 99 Kumsuk building 501
				Seoul    05808
				KR

6C-93-08   (hex)		Shenzhen EZpro Sound & Light Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Shenzhen EZpro Sound & Light Technology Co., Ltd.
				E2?TCL International E City,1001 Zhong Shan Yuan Rd,Nanshan District
				shenz  guangdong  518055
				CN

0C-86-29   (hex)		HagerEnergy GmbH
700000-7FFFFF     (base 16)		HagerEnergy GmbH
				Karlstrasse 5
				Osnabrueck    49074
				DE

30-43-D7   (hex)		Xiaoniu network technology (Shanghai) Co., Ltd.
C00000-CFFFFF     (base 16)		Xiaoniu network technology (Shanghai) Co., Ltd.
				Room 706, building 3, no.20 east road, jingan district.
				Shang hai    200040
				CN

6C-93-08   (hex)		Estelar s.r.o
400000-4FFFFF     (base 16)		Estelar s.r.o
				Palackého 744/1
				Holešov  ?eská republika  76901
				CZ

08-26-AE   (hex)		Flextronics International Kft
A00000-AFFFFF     (base 16)		Flextronics International Kft
				Zrínyi Miklós str. 38.
				Zalaegerszeg    8900
				HU

38-1F-26   (hex)		Airmaster A/S
400000-4FFFFF     (base 16)		Airmaster A/S
				Industrivej 59
				Aars    9600
				DK

38-1F-26   (hex)		HWACHANG CORPORATION 
D00000-DFFFFF     (base 16)		HWACHANG CORPORATION 
				90, NONGGONGANJI-GIL
				SOCHO-SI    24899
				KR

18-A5-9C   (hex)		Residence Control Ltd
800000-8FFFFF     (base 16)		Residence Control Ltd
				Cvetan Vuchkov 7
				Sofia  Sofia  1614
				BG

18-A5-9C   (hex)		Actiontec Electronics Inc.
200000-2FFFFF     (base 16)		Actiontec Electronics Inc.
				2445 Augustine Dr #501
				Santa Clara   CA  95054
				US

18-A5-9C   (hex)		IT-1
400000-4FFFFF     (base 16)		IT-1
				260, Changnyong-daero
				Yeongtong-gu, Suwon-si  Gyeonggi-do  16229
				KR

7C-70-BC   (hex)		Motec GmbH
A00000-AFFFFF     (base 16)		Motec GmbH
				287 27 Road
				Grand Junction  CO  81503
				US

1C-59-74   (hex)		Syntax technology(tianjin)Co.,LTD
400000-4FFFFF     (base 16)		Syntax technology(tianjin)Co.,LTD
				Room 510-5,Comprehensive Office Building,Carpet Industrial Park,Wuqing District 
				Tianjin  Tianjin  301700
				CN

1C-59-74   (hex)		Beijing Flintec Electronic Technology Co.,Ltd.
B00000-BFFFFF     (base 16)		Beijing Flintec Electronic Technology Co.,Ltd.
				Room 102,Building No.6,China Technology Venture Park,No.8,LaiGuangYing West Road,ChaoYang District 
				Beijing  Beijing  100012
				CN

1C-59-74   (hex)		Shanghai Laisi Information Technology Co.,Ltd
900000-9FFFFF     (base 16)		Shanghai Laisi Information Technology Co.,Ltd
				1001,21#,No.1158 Zhongxin RD,Songjiang district Shanghai
				shanghai    201614
				CN

1C-59-74   (hex)		Square Inc.
600000-6FFFFF     (base 16)		Square Inc.
				1455 Market St.
				San Francisco  CA  94103
				US

6C-15-24   (hex)		Shenzhen Electron Technology Co., LTD.
500000-5FFFFF     (base 16)		Shenzhen Electron Technology Co., LTD.
				Building 2, Yingfeng Industrial Zone, Tantou Community, Songgang Street, Bao'an District
				Shenzhen  Guangzhou  51800
				CN

6C-15-24   (hex)		ShenZhen Chainway Information Technology Co., Ltd.
800000-8FFFFF     (base 16)		ShenZhen Chainway Information Technology Co., Ltd.
				 9F Building2, Phase2, Gaoxinqi Industrial Park ,  Bao'an District
				ShenZhen  GuangDong  518102
				CN

6C-15-24   (hex)		Annapurna labs
B00000-BFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

6C-15-24   (hex)		Linkplay
200000-2FFFFF     (base 16)		Linkplay
				891 W. Washington Ave.
				Sunnyvale  CA  94086
				US

6C-15-24   (hex)		CORAL-TAIYI
C00000-CFFFFF     (base 16)		CORAL-TAIYI
				8F-3, No. 200, Gangqian Rd, Neihu District
				Taipei City    114
				TW

6C-15-24   (hex)		DEFA AS
000000-0FFFFF     (base 16)		DEFA AS
				Blingsmovegen 30
				Nesbyen    3540
				NO

C4-A1-0E   (hex)		O-NET Industrial Technologies (Shenzhen) Limited
500000-5FFFFF     (base 16)		O-NET Industrial Technologies (Shenzhen) Limited
				501, Maile building, building 2, No. 28, Cuijing Road, Zhukeng community, Longtian street, Pingshan District
				Shenzhen  Guangdong  518118
				CN

70-50-E7   (hex)		Nippon Pulse America, Inc.
600000-6FFFFF     (base 16)		Nippon Pulse America, Inc.
				4 Corporate Drive
				Radford  VA  24141-5100
				US

C4-A1-0E   (hex)		Focus-on
C00000-CFFFFF     (base 16)		Focus-on
				Kerkeplaat 12
				Dordrecht    3313LC
				NL

70-50-E7   (hex)		Eta Compute Inc.
D00000-DFFFFF     (base 16)		Eta Compute Inc.
				182 S. Murphy Ave
				Sunnyvale  CA  94086
				US

80-02-F4   (hex)		Wuhan Glory Road Intelligent Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Wuhan Glory Road Intelligent Technology Co., Ltd.
				18F,Magic Cube Building,Optics Valley Core Center,No.303 Optics Valley Avenue,East Lake High-tech Development Zone
				Wuhan  Hubei  430073
				CN

80-02-F4   (hex)		Sichuan lookout environment protection technology co.,Ltd
100000-1FFFFF     (base 16)		Sichuan lookout environment protection technology co.,Ltd
				No. 1015, floor 10, unit 2, building 1, No. 1616, Nanhua Road, high tech Zone
				Chengdu  Sichuan  610052
				CN

8C-51-09   (hex)		PROCET Technology Co., Ltd(HK)
200000-2FFFFF     (base 16)		PROCET Technology Co., Ltd(HK)
				Flat B,4/F, Kjngswell Commercial Tower, 171-173 Lockhard Road, Wanchai, Hongkong
				Hong kong    999077
				HK

80-02-F4   (hex)		Alfred Systems Inc
E00000-EFFFFF     (base 16)		Alfred Systems Inc
				13F, No. 2, Sec. 5, Xinyi Rd.
				Taipei city    110
				TW

8C-51-09   (hex)		SpotterRF LLC
C00000-CFFFFF     (base 16)		SpotterRF LLC
				720 Timpanogos Parkway
				Orem  UT  84097
				US

0C-7F-ED   (hex)		Tango Networks Inc
200000-2FFFFF     (base 16)		Tango Networks Inc
				2801 Network Blvd, Suite 200
				Frisco  TX  TX 75034
				US

0C-7F-ED   (hex)		Purple Mountain ,Inc
400000-4FFFFF     (base 16)		Purple Mountain ,Inc
				New District
				SuZhou  JiangSu  215000
				CN

FC-61-79   (hex)		CHOEUNENG
400000-4FFFFF     (base 16)		CHOEUNENG
				22, Ildong-ro, Sangnok-gu
				Ansan-si  Gyeonggi-do  15326
				KR

FC-61-79   (hex)		EchoStar Mobile
300000-3FFFFF     (base 16)		EchoStar Mobile
				25/28 NORTH WALL QUAY, DUBLIN 1, D01H104        Ireland
				Dublin  Ireland  D01H104
				IE

0C-7F-ED   (hex)		environmental systems corporation
E00000-EFFFFF     (base 16)		environmental systems corporation
				122F Commerce Park Drive
				Barrie    Ontario  L4N 8W8 
				CA

FC-61-79   (hex)		Hangzhou LiDe Communication Co.,Ltd
600000-6FFFFF     (base 16)		Hangzhou LiDe Communication Co.,Ltd
				No.188,DongJia Rd,Tonglu Econominc Development Zone,Hangzhou,Zhejiang,
				Hangzhou    311500
				CN

20-85-93   (hex)		Great Lite International
700000-7FFFFF     (base 16)		Great Lite International
				11F., No.207-2, Sec. 3, Beixin Rd., Xindian Dist.,
				New Taipei City  Taiwan  23143
				TW

4C-4B-F9   (hex)		Tecnoplus Srl
900000-9FFFFF     (base 16)		Tecnoplus Srl
				Via Cilavegna, 53
				Gravellona Lomellina  Pavia  27020
				IT

98-06-37   (hex)		Summa nv
200000-2FFFFF     (base 16)		Summa nv
				Rochesterlaan 6
				Gistel    8470
				BE

98-06-37   (hex)		Shanghai Jinnian information technology Co. Ltd
E00000-EFFFFF     (base 16)		Shanghai Jinnian information technology Co. Ltd
				Room 102-105 ,block 1 , No.33 leshan Road
				Shanghai  Shanghai  200030
				CN

24-15-10   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

44-D5-F2   (hex)		Auctus Technologies Co.,Ltd.
900000-9FFFFF     (base 16)		Auctus Technologies Co.,Ltd.
				17F, Building 3, China Science and Technology Development Park, No. 009, 1st South Gaoxin Road, Nanshan District
				Shenzhen  Guangdong  518000
				CN

44-D5-F2   (hex)		Shenzhen Qiutian Technology Co.,Ltd
700000-7FFFFF     (base 16)		Shenzhen Qiutian Technology Co.,Ltd
				5B01 5F Wangtang Building Xingao Road Xili Nanshan District
				 Shenzhen  Guangdong  518000
				CN

44-D5-F2   (hex)		Joint-Stock Company Research and Development Center ELVEES
E00000-EFFFFF     (base 16)		Joint-Stock Company Research and Development Center ELVEES
				Proezd 4922, Dom 4, Stroenie 2
				Zelenograd  Moscow  124498
				RU

44-D5-F2   (hex)		neocontrol soluções em automação
C00000-CFFFFF     (base 16)		neocontrol soluções em automação
				rua santa fe 100
				belo horizonte  MG  30320-130
				BR

D0-5F-64   (hex)		Hangzhou ToupTek Photonics Co., Ltd.
100000-1FFFFF     (base 16)		Hangzhou ToupTek Photonics Co., Ltd.
				4F, Block A, B, Building 2, NO.321, Jinpeng Street, Xihu District
				Hangzhou  Zhejiang  310030
				CN

FC-A4-7A   (hex)		Shenzhen VMAX New Energy Co., Ltd.
100000-1FFFFF     (base 16)		Shenzhen VMAX New Energy Co., Ltd.
				5F, Fengyun Building, No.5 Road, Hi-Tech Industrial Park (North), Nanshan District, 
				Shenzhen  Guangdong  518057
				CN

D0-5F-64   (hex)		Beijing Core Shield Group Co., Ltd.
700000-7FFFFF     (base 16)		Beijing Core Shield Group Co., Ltd.
				2/F, Tower C, Building 4,  Zhongguancun Software Park, No.8 Dongbeiwang West Road, Haidian District, Beijing, China
				Beijing    100085
				CN

2C-16-BD   (hex)		Shenzhen elink smart Co., ltd
800000-8FFFFF     (base 16)		Shenzhen elink smart Co., ltd
				Floor 2,Building A , Hongtian Xinfengze Industrial   Park Huang Pu Community , Xin Qiao District ,Baoan Area
				shenzhen  Guangdong Province  518101
				CN

2C-16-BD   (hex)		Shenzhen Haiying Wire Tech Co., Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Haiying Wire Tech Co., Ltd.
				5/F, No. 6 Bldg, Longcheng Industrial Park, Longhua District
				Shenzhen  Guangdong  518110
				CN

FC-A4-7A   (hex)		Cliptech Industria e Comercio Ltda
300000-3FFFFF     (base 16)		Cliptech Industria e Comercio Ltda
				ROD VICE PREF HERMENEGILDO TONOLI, 2285
				ITUPEVA  SAO PAULO  13295000
				BR

B4-A2-EB   (hex)		Softel SA de CV
400000-4FFFFF     (base 16)		Softel SA de CV
				Camino a Santa Teresa 
				Tlalpan    14010
				MX

B4-A2-EB   (hex)		Katerra Inc
200000-2FFFFF     (base 16)		Katerra Inc
				2494 Sand Hill Rd, Bldg 7, Suite 100
				Menlo Park  CA  94025-6981
				US

80-E4-DA   (hex)		Private
F00000-FFFFFF     (base 16)		Private

8C-59-3C   (hex)		Qbic Technology Co., Ltd
600000-6FFFFF     (base 16)		Qbic Technology Co., Ltd
				26F.-12, No.99, Sec. 1, Xintai 5th Rd., Xizhi Dist.,
				New Taipei     22175
				TW

8C-59-3C   (hex)		IDRO-ELETTRICA S.P.A.
D00000-DFFFFF     (base 16)		IDRO-ELETTRICA S.P.A.
				VIA BELLINI 2
				SAN CESARIO SUL PANARO  ITALY/MODENA  41018
				IT

8C-59-3C   (hex)		Chongqing beimoting technology co.ltd
300000-3FFFFF     (base 16)		Chongqing beimoting technology co.ltd
				97-2 keyuan 2nd street, jiulongpo district,
				Chongqing  Chongqing  400039
				CN

8C-59-3C   (hex)		Fujian Chaozhi Group Co., Ltd.
000000-0FFFFF     (base 16)		Fujian Chaozhi Group Co., Ltd.
				Chaozhi Group, 13th Floor, Zhongqing Building, Haixi Science and Technology Park, Shangjie Town, Minhou County
				Fuzhou  Fujian  350000
				CN

D0-C8-57   (hex)		CHUNGHSIN INTERNATIONAL ELECTRONICS CO.,LTD.
B00000-BFFFFF     (base 16)		CHUNGHSIN INTERNATIONAL ELECTRONICS CO.,LTD.
				618-2# Gongren West Road,Jiaojiang,
				Taizhou  Zhejiang  317700
				CN

D0-C8-57   (hex)		DALI A/S
100000-1FFFFF     (base 16)		DALI A/S
				Dali Alle 1
				Norager    9610
				DK

BC-97-40   (hex)		ForoTel
B00000-BFFFFF     (base 16)		ForoTel
				77, Shaumyana Str. 
				Rostov-na-Donu  UFO  344079
				RU

BC-97-40   (hex)		Gaodi Rus
800000-8FFFFF     (base 16)		Gaodi Rus
				Korneeva, 14
				Elektrostal  Moscow region  144009
				RU

60-95-CE   (hex)		AdvanWISE Corporation
500000-5FFFFF     (base 16)		AdvanWISE Corporation
				No.11, Aly. 18, Ln. 85, Fuqun St., Xiangshan Dist.
				Hsinchu    30067
				TW

84-8B-CD   (hex)		Dunst tronic GmbH
800000-8FFFFF     (base 16)		Dunst tronic GmbH
				Seevetalstraße, 2
				Seevetal  Niedersachsen  21217
				DE

84-8B-CD   (hex)		Annapurna labs
300000-3FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

84-8B-CD   (hex)		Emotiv Inc
E00000-EFFFFF     (base 16)		Emotiv Inc
				490 Post Street
				San Francisco  CA  94102
				US

84-8B-CD   (hex)		ENGISAT LDA
D00000-DFFFFF     (base 16)		ENGISAT LDA
				RUA CENTRAL SAO LOURENÇO Nº 312
				VILAR DE ANDORINHO  PORTO  4430-358
				PT

84-8B-CD   (hex)		Smart Code (Shenzhen) Technology Co.,Ltd
700000-7FFFFF     (base 16)		Smart Code (Shenzhen) Technology Co.,Ltd
				Keji North 3rd Rd
				Shenzhen  guangdong  518000
				CN

B0-FD-0B   (hex)		Fasii Information Technology (Shanghai) Ltd.
400000-4FFFFF     (base 16)		Fasii Information Technology (Shanghai) Ltd.
				Room 5011, Building 1, No.335 Guoding Road, Yangpu District
				Shanghai  Shanghai  200433
				CN

B0-FD-0B   (hex)		TAE HYUNG Industrial Electronics Co., Ltd.
000000-0FFFFF     (base 16)		TAE HYUNG Industrial Electronics Co., Ltd.
				301-404, Bucheon Technopark, 345, Seokcheon-ro
				Bucheon-si  Gyeonggi-do  14501
				KR

84-8B-CD   (hex)		Sphera Telecom
A00000-AFFFFF     (base 16)		Sphera Telecom
				Pos. Moscowskiy, 22-nd km of Kievskoye highway, household 4, building 2, body G, office 802G
				Moscow    108811
				RU

C8-2C-2B   (hex)		Shiftall Inc.
A00000-AFFFFF     (base 16)		Shiftall Inc.
				4F TokyoDaiwa Bldg., 2-6-10 Nihonbashibakurocho, 
				Chuo,   Tokyo  1030002
				JP

C8-2C-2B   (hex)		BIOT Sp. z o.o.
900000-9FFFFF     (base 16)		BIOT Sp. z o.o.
				Nowy Kisielin-Nowa 7
				Zielona Góra  Lubuskie  66-002
				PL

E4-1E-0A   (hex)		Shanghai LeXiang Technology Co., Ltd
E00000-EFFFFF     (base 16)		Shanghai LeXiang Technology Co., Ltd
				Floor 6,Building 8,Yanjiaqiao Road,Pudong Area ,Shanghai ,China
				shanghai    200125
				CN

C8-2C-2B   (hex)		Fungible, Inc.
000000-0FFFFF     (base 16)		Fungible, Inc.
				3201 Scott Blvd., 2nd floor
				Santa Clara  CA  95054
				US

B0-FD-0B   (hex)		Habana Labs LTD
D00000-DFFFFF     (base 16)		Habana Labs LTD
				5 Tarshish St,
				Caesarea    3079821
				IL

E4-1E-0A   (hex)		TELETASK BELGIUM
C00000-CFFFFF     (base 16)		TELETASK BELGIUM
				Ottergemsesteenweg-zuid 729
				GENT  Oost-Vlaanderen  9000
				BE

C8-63-14   (hex)		GRINBI PARTNERS
600000-6FFFFF     (base 16)		GRINBI PARTNERS
				222, Dogok-ro, Gangnam-gu
				Seoul    06272
				KR

E4-1E-0A   (hex)		ROMO Wind A/S
D00000-DFFFFF     (base 16)		ROMO Wind A/S
				Olof Palmes Allé 47
				Aarhus N    8200
				DK

C8-63-14   (hex)		Shenzhen Wesion Technology Co., Ltd
700000-7FFFFF     (base 16)		Shenzhen Wesion Technology Co., Ltd
				A511, Mingyou Purchasing Center, Baoyuan Road, Xixiang Street
				Shenzhen  Guangdong  518102
				CN

C8-63-14   (hex)		Shenzhen Zero Zero Infinity Technology Co.，Ltd.
400000-4FFFFF     (base 16)		Shenzhen Zero Zero Infinity Technology Co.，Ltd.
				309 Rainbow Technology Building, 36 Gaoxin North 6th Road, Xili Street
				Shenzhen  Guangdong  518000
				CN

C8-63-14   (hex)		Telematix AG
D00000-DFFFFF     (base 16)		Telematix AG
				Freiburgstrasse 251
				Bern  Bern  3018
				CH

C8-63-14   (hex)		TrackMan
300000-3FFFFF     (base 16)		TrackMan
				Stubbeled 2
				Vedbaek    2950
				DK

34-E1-D1   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

FC-D2-B6   (hex)		Oviss Labs Inc.
800000-8FFFFF     (base 16)		Oviss Labs Inc.
				46259 Warm Springs Blvd
				Fremont  CA  94539
				US

34-E1-D1   (hex)		Tianjin Sublue Ocean Science & Technology Co., Ltd
000000-0FFFFF     (base 16)		Tianjin Sublue Ocean Science & Technology Co., Ltd
				No.29 Factory No.156 Nanhai Road,TEDA
				Tianjin    300050
				CN

34-E1-D1   (hex)		Doki Technologies Limited
500000-5FFFFF     (base 16)		Doki Technologies Limited
				Unit 601,Tower One, Silvercord, 30 Canton Road, Tsim Sha Tsui
				Kowloon    00000
				HK

34-E1-D1   (hex)		Teton Camera LLC
200000-2FFFFF     (base 16)		Teton Camera LLC
				PO BOX 648
				PINEDALE  WY  82941-0648
				US

74-5B-C5   (hex)		EDOMO Systems GmbH
800000-8FFFFF     (base 16)		EDOMO Systems GmbH
				Obertorplatz 2
				Landau  Deutschland (DEU)  76829
				DE

90-C6-82   (hex)		Private
F00000-FFFFFF     (base 16)		Private

FC-D2-B6   (hex)		Grandway Technology (Shenzhen) Limited
500000-5FFFFF     (base 16)		Grandway Technology (Shenzhen) Limited
				Block 7, Zhu Keng Industrial Zone
				Ping Shan District  Shenzhen  518118
				CN

FC-D2-B6   (hex)		CG POWER AND INDUSTRIAL SOLUTIONS LTD
000000-0FFFFF     (base 16)		CG POWER AND INDUSTRIAL SOLUTIONS LTD
				A-3, MIDC , AMBAD 
				NASHIK  MAHARASHTRA  422010
				IN

FC-D2-B6   (hex)		T CHIP DIGITAL TECHNOLOGY CO.LTD
B00000-BFFFFF     (base 16)		T CHIP DIGITAL TECHNOLOGY CO.LTD
				Room 320, C Tower, Jingji Building, HuaFeng Headquarter, Xixiang, Baoan
				SHENZHEN  Guangdong  518000
				CN

E4-4C-C7   (hex)		FLK information security technology Co,. Ltd
E00000-EFFFFF     (base 16)		FLK information security technology Co,. Ltd
				Room 1801, Yinfeng Building, No. 1505, Binsheng Road, Binjiang District
				Hangzhou  Zhejiang  310051
				CN

E4-4C-C7   (hex)		IAG GROUP LTD
800000-8FFFFF     (base 16)		IAG GROUP LTD
				IAG Industrial Park, Jiuwei, Xixiang Town, Baoan, Shenzhen, China.
				shenzhen    518000
				CN

74-5B-C5   (hex)		uGrid Network Inc.
400000-4FFFFF     (base 16)		uGrid Network Inc.
				602 Gabriola Way
				Ottawa  Ontario  K2T 0M2
				CA

E4-4C-C7   (hex)		Muzik Inc
A00000-AFFFFF     (base 16)		Muzik Inc
				9220 Sunset Blvd #112
				West Hollywood    CA 90069
				US

4C-BC-98   (hex)		Airtex Manufacturing Partnership
900000-9FFFFF     (base 16)		Airtex Manufacturing Partnership
				1441 Hastings Cres. SE
				Calgary  Alberta  T2G 4C8
				CA

4C-BC-98   (hex)		Voegtlin Instruments GmbH
700000-7FFFFF     (base 16)		Voegtlin Instruments GmbH
				Langenhagstrasse 1
				Aesch    CH-4147
				CH

4C-BC-98   (hex)		Heliotis AG
C00000-CFFFFF     (base 16)		Heliotis AG
				Längenbold 5
				Root    6037
				CH

4C-BC-98   (hex)		Humanplus Intelligent Robotics Technology Co.,Ltd.
600000-6FFFFF     (base 16)		Humanplus Intelligent Robotics Technology Co.,Ltd.
				Room507,5th Floor, Zhongguancun Frontier Technology Innovation Building, No. 67 North Fourth Ring Road,Haidian District,
				Beijing  Beijing  100089
				CN

2C-26-5F   (hex)		Private
F00000-FFFFFF     (base 16)		Private

A0-BB-3E   (hex)		Private
F00000-FFFFFF     (base 16)		Private

2C-6A-6F   (hex)		Private
F00000-FFFFFF     (base 16)		Private

4C-65-A8   (hex)		ZMIN Technologies
B00000-BFFFFF     (base 16)		ZMIN Technologies
				Room 403-405, Building C, Baoan New Generation Information Technology Industrial Park, No.139, Chuangye 2 Rd., Baoan District
				ShenZhen  GuangDong  518101
				CN

E0-5A-9F   (hex)		Chengdu Song Yuan Electronic Technology Co.,Ltd
200000-2FFFFF     (base 16)		Chengdu Song Yuan Electronic Technology Co.,Ltd
				Building 63 Cui Feng International, No.366 Bai Cao Road, High-tech West Zone
				Chengdu  Sichuan  610000
				CN

E0-5A-9F   (hex)		Contemporary Amperex Technology Co., Limited
A00000-AFFFFF     (base 16)		Contemporary Amperex Technology Co., Limited
				No.2 Xingang Road,  Zhangwan Town, Jiaocheng District
				Ningde  Fujian  352000
				CN

E0-5A-9F   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

E0-5A-9F   (hex)		Mountz, Inc.
D00000-DFFFFF     (base 16)		Mountz, Inc.
				1080 N. 11th Street
				San Jose  CA  95112
				US

E0-5A-9F   (hex)		TRYEN
500000-5FFFFF     (base 16)		TRYEN
				Manan-gu Anyang-ro 110
				Anyang  Kyeong-gi  14035
				KR

38-B1-9E   (hex)		Freedompro Srl
100000-1FFFFF     (base 16)		Freedompro Srl
				Via Frova, 34
				Cinisello Balsamo    20092
				IT

D8-86-0B   (hex)		Krspace
100000-1FFFFF     (base 16)		Krspace
				Building 1, Junhao Central Park Plaza
				ChaoYang District  Beijing  100125
				CN

38-B1-9E   (hex)		Doepke Schaltgeräte GmbH
900000-9FFFFF     (base 16)		Doepke Schaltgeräte GmbH
				Stellmacherstr. 11
				Norden  Niedersachsen  26506
				DE

28-36-38   (hex)		Swisson AG
C00000-CFFFFF     (base 16)		Swisson AG
				Fabrikstrasse 21
				Lyss    3250
				CH

CC-D3-9D   (hex)		Evoko Unlimited AB
100000-1FFFFF     (base 16)		Evoko Unlimited AB
				Hästholmsvägen 32
				Nacka    13130
				SE

D4-25-CC   (hex)		bvk technology
500000-5FFFFF     (base 16)		bvk technology
				Mithatpasa Mah. Serin Cikmazi No:4 C Blok Kemerburgaz, Eyupsultan
				Istanbul  Istanbul  34075
				TR

D4-25-CC   (hex)		POSNET Polska S.A.
C00000-CFFFFF     (base 16)		POSNET Polska S.A.
				ul. Municypalna 33
				Warszawa    02-281
				PL

D4-25-CC   (hex)		MusicLens Inc.
200000-2FFFFF     (base 16)		MusicLens Inc.
				311 E VALLEY BLVD#112 PMB27
				SANGABRIEL  CA  91776
				US

CC-D3-9D   (hex)		Lubelskie Fabryki Wag FAWAG S.A.
A00000-AFFFFF     (base 16)		Lubelskie Fabryki Wag FAWAG S.A.
				Łęczyńska 58
				Lublin    20-954
				PL

38-B1-9E   (hex)		Beijing Memblaze Technology Co Ltd
700000-7FFFFF     (base 16)		Beijing Memblaze Technology Co Ltd
				Building B2,Dongsheng Park, 66 Xixiaokou Road, Haidian
				Beijing  Beijing  100192
				CN

9C-69-B4   (hex)		EA Technology Ltd
100000-1FFFFF     (base 16)		EA Technology Ltd
				Capenhurst Technology Park
				Chester  Cheshire  CH16ES
				GB

D4-25-CC   (hex)		DOLBY LABORATORIES, INC.
800000-8FFFFF     (base 16)		DOLBY LABORATORIES, INC.
				100 Potrero Avenue
				San Francisco  CA  94103-4938
				US

68-91-D0   (hex)		G-TECH Instruments Inc.
400000-4FFFFF     (base 16)		G-TECH Instruments Inc.
				2F.-2, No.83, Sec. 2, Gongdao 5th Rd., East Dist.
				Hsinchu    30070
				TW

9C-69-B4   (hex)		Intellect module LLC
D00000-DFFFFF     (base 16)		Intellect module LLC
				Krasnogo kursanta str. 25 lit. J
				Saint-Petersburg    197110
				RU

D4-25-CC   (hex)		BlueCats US, LLC
700000-7FFFFF     (base 16)		BlueCats US, LLC
				6767 OLD MADISON PIKE NW, SUITE 300
				Huntsville  AL  35806
				US

4C-91-7A   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

4C-91-7A   (hex)		Erlab DFS SAS
A00000-AFFFFF     (base 16)		Erlab DFS SAS
				Parc d'Affaires des Portes - BP403
				Val de Reuil    27104
				FR

6C-DF-FB   (hex)		Sercomm Corporation.
200000-2FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

4C-91-7A   (hex)		AvertX
B00000-BFFFFF     (base 16)		AvertX
				23221 E. Knox Ave
				Liberty Lake  WA  99019
				US

6C-DF-FB   (hex)		Shenzhen HDCVT Technology
000000-0FFFFF     (base 16)		Shenzhen HDCVT Technology
				Floor 7, Building 5, Lihe Industrial Park, Songbai Road, Xili Street, Nanshan District
				Shenzhen  Guangdong  518055
				CN

7C-BC-84   (hex)		Guangzhou Puppyrobot Technology Co.Ltd Beijing Branch
B00000-BFFFFF     (base 16)		Guangzhou Puppyrobot Technology Co.Ltd Beijing Branch
				R&F center,63 East middle 3rd ring road
				beijing    10000
				CN

7C-BC-84   (hex)		HITIQ LIMITED
900000-9FFFFF     (base 16)		HITIQ LIMITED
				628 Newcastle St
				Leederville  WA  6007
				AU

7C-BC-84   (hex)		Tibit Communications
C00000-CFFFFF     (base 16)		Tibit Communications
				1 Willowbrook Court, Suite 150
				Petaluma  CA  94954
				US

7C-BC-84   (hex)		CONTINENTAL
400000-4FFFFF     (base 16)		CONTINENTAL
				1 AVENUE PAUL OURLIAC
				TOULOUSE    31100
				FR

7C-BC-84   (hex)		3S Technology Co., Ltd.
200000-2FFFFF     (base 16)		3S Technology Co., Ltd.
				301-1103, 345, Seokcheon-ro
				Bucheon-si  Gyeonggi-do  14501
				KR

7C-BC-84   (hex)		AG Neovo
000000-0FFFFF     (base 16)		AG Neovo
				5F-1, No. 3-1, Park Street, Nangang District, Taipei, 11503, Taiwan
				Taipei    11503
				TW

98-F9-C7   (hex)		Beijing Horizon Information Technology Co., Ltd
300000-3FFFFF     (base 16)		Beijing Horizon Information Technology Co., Ltd
				3F,Unit H, West Gate, Hailong Mansion, No.1 Zhongguancun Street, Haidian District
				Beijing    100080
				CN

9C-43-1E   (hex)		HAESUNG DS
200000-2FFFFF     (base 16)		HAESUNG DS
				8F, Haesung 2 Building, 508, Teheran-ro, Gangnam-gu
				Seoul    06178
				KR

0C-FE-5D   (hex)		Maksat Technologies P Ltd
D00000-DFFFFF     (base 16)		Maksat Technologies P Ltd
				D-10/6, Okhla, Phase-I, Okhla
				New Delhi  Delhi  110020
				IN

98-F9-C7   (hex)		ShenZhen Chuangwei Electronic Appliance Co.,Ltd
C00000-CFFFFF     (base 16)		ShenZhen Chuangwei Electronic Appliance Co.,Ltd
				4F & 6F, Overseas plant south, Skyworth Industrial Park, Shiyan Street, Bao'an  District,
				Shenzhen  Guangdong  518101
				CN

98-F9-C7   (hex)		HIROIA Communications Pte. Ltd. Taiwan Branch
B00000-BFFFFF     (base 16)		HIROIA Communications Pte. Ltd. Taiwan Branch
				7F., No.189, Xinhu 3rd Rd., Neihu Dist.,
				Taipei City    11494
				TW

0C-FE-5D   (hex)		Celerway Communication AS
900000-9FFFFF     (base 16)		Celerway Communication AS
				Martin Lingesvei 25
				Fornebu    1364
				NO

0C-FE-5D   (hex)		Fender Musical Instrument
100000-1FFFFF     (base 16)		Fender Musical Instrument
				17600 N Perimeter DR #100
				Scottsdale  AZ  85255
				US

0C-FE-5D   (hex)		YINUO-LINK LIMITED
B00000-BFFFFF     (base 16)		YINUO-LINK LIMITED
				5 Floor, Chuangyecheng,Xinghua Road,Xingwei,Fuyong
				Shenzhen  Guangdong  518103
				CN

80-0A-80   (hex)		Private
F00000-FFFFFF     (base 16)		Private

C0-D3-91   (hex)		Private
B00000-BFFFFF     (base 16)		Private

1C-FD-08   (hex)		MESHBOX FOUNDATION PTE. LTD.
E00000-EFFFFF     (base 16)		MESHBOX FOUNDATION PTE. LTD.
				152 Beach Road #14-02 GATEWAY EAST TOWER
				SINGAPORE    189721
				SG

1C-FD-08   (hex)		Tianjin Keyvia Electric Co.,Ltd
D00000-DFFFFF     (base 16)		Tianjin Keyvia Electric Co.,Ltd
				No.15 HaitaiFazhanErlu Road, Binhai Hi-tech Industrial Huayuan Development Area(Outer Ring)
				Tianjin  Tianjin  300392
				CN

1C-FD-08   (hex)		Shanghai YottaTech Co Ltd (上海尧它科技有限公司）
C00000-CFFFFF     (base 16)		Shanghai YottaTech Co Ltd (上海尧它科技有限公司）
				399 keyuan Rd, Pudong New District
				Shanghai    201203
				CN

1C-FD-08   (hex)		Banmak Technogies Co.,Ltd
A00000-AFFFFF     (base 16)		Banmak Technogies Co.,Ltd
				302, Building R3-B, High-Tech Park
				Shenzhen  Guangdong  518057
				CN

1C-FD-08   (hex)		Shenzhen SEWO Technology Co.,Ltd.
100000-1FFFFF     (base 16)		Shenzhen SEWO Technology Co.,Ltd.
				Busha Road No 231. Buji Street. Longgang District.
				Shenzhen  Guangdong  518112
				CN

6C-5C-3D   (hex)		Vertiv Industrial Systems
200000-2FFFFF     (base 16)		Vertiv Industrial Systems
				30 avenue Montgolfier
				Chassieu    69684
				FR

6C-5C-3D   (hex)		KWONG MING ELECTRICAL MANUFACTORY LIMITED
300000-3FFFFF     (base 16)		KWONG MING ELECTRICAL MANUFACTORY LIMITED
				A3 bldg, Kwong Ming, Technology Industrial Zone, Shiwan Town, Boluo County 
				Huizhou  Guangdong  516100
				CN

B8-D8-12   (hex)		Private
F00000-FFFFFF     (base 16)		Private

A8-3F-A1   (hex)		Imecon Engineering SrL
000000-0FFFFF     (base 16)		Imecon Engineering SrL
				via Gerola 13/15
				Fiesco  CR  26010
				IT

A8-3F-A1   (hex)		Shenzhen ITLONG Intelligent Technology Co.,Ltd
900000-9FFFFF     (base 16)		Shenzhen ITLONG Intelligent Technology Co.,Ltd
				12th floor, Building C1, Nanshan Zhiyuan, 1001 Xueyuan Avenue , Nanshan District
				Shenzhen  Guangdong  518055
				CN

3C-6A-2C   (hex)		WICKS Co., Ltd.
900000-9FFFFF     (base 16)		WICKS Co., Ltd.
				202,1-29 shingi takasu
				kochi City  Kochi  781-8103
				JP

A8-3F-A1   (hex)		Sercomm Corporation.
500000-5FFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

30-0A-60   (hex)		AVIC JONHON OPTRONIC TECHNOLOGY CO., LTD.
400000-4FFFFF     (base 16)		AVIC JONHON OPTRONIC TECHNOLOGY CO., LTD.
				Zhoushan Road10,Jianxi District,Luoyang City
				Luoyang City  Henan Province  471003
				CN

30-0A-60   (hex)		Bronkhorst High-Tech BV
800000-8FFFFF     (base 16)		Bronkhorst High-Tech BV
				Nijverheidsstraat 1a
				Ruurlo  Gelderland  NL-7261AK
				NL

A4-ED-43   (hex)		Paragon Business Solutions Ltd.
B00000-BFFFFF     (base 16)		Paragon Business Solutions Ltd.
				303-5th Avenue, Suite # 1007
				New York    10016
				US

A4-ED-43   (hex)		Shanghai Mission Information Technologies (Group) Co.,Ltd
200000-2FFFFF     (base 16)		Shanghai Mission Information Technologies (Group) Co.,Ltd
				Room 803, modern traffic building (East District), 218 Hengfeng Road, Jingan District
				Shanghai    200041
				CN

A4-ED-43   (hex)		Sweam AB
000000-0FFFFF     (base 16)		Sweam AB
				Kistagången 12
				Kista  Stockholm  16440
				SE

A0-28-33   (hex)		Precision Planting, LLC.
E00000-EFFFFF     (base 16)		Precision Planting, LLC.
				23207 Townline Rd.
				Tremont  IL  61568
				US

84-89-EC   (hex)		SmartGiant Technology
000000-0FFFFF     (base 16)		SmartGiant Technology
				1 North Zhong Jia Zhuang, Shi Gang Dong, Da Long Street
				Guangzhou  Guangdong  510000
				CN

84-89-EC   (hex)		Zephyr Engineering, Inc.
500000-5FFFFF     (base 16)		Zephyr Engineering, Inc.
				2412 W. Huntington Dr.
				Tempe  AZ  85282
				US

84-89-EC   (hex)		Aerionics Inc.
300000-3FFFFF     (base 16)		Aerionics Inc.
				3601 N St Paul Avenue
				Sioux Falls  SD  57104
				US

A0-28-33   (hex)		FlexLink AB
B00000-BFFFFF     (base 16)		FlexLink AB
				BYFOGDEGATAN 11
				GOTEBORG    41505
				SE

68-91-D0   (hex)		Ambitio LLC
300000-3FFFFF     (base 16)		Ambitio LLC
				10505 NW 27th ST
				Doral  FL  33172
				US

D4-7C-44   (hex)		Sammi Onformation Systems
400000-4FFFFF     (base 16)		Sammi Onformation Systems
				Gasan Digital 1-ro 212
				Geumcheon-gu  Seoul  08502
				KR

9C-F6-DD   (hex)		Shenzhen Xtooltech Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen Xtooltech Co., Ltd
				10574 Acacia St, Suite D4
				Rancho Cucamonga  CA  91730
				US

78-C2-C0   (hex)		Ory Laboratory Co., Ltd.
400000-4FFFFF     (base 16)		Ory Laboratory Co., Ltd.
				502 Bravi Mitaka, 1-3-11 Nishikubo
				Musashino-shi  Tokyo  180-0013
				JP

30-09-F9   (hex)		Beijing Netswift Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Beijing Netswift Technology Co.,Ltd.
				No. 7, 7th floor, No.49 Zhichun Road, Haidian District
				Beijing  Beijing  100190 
				CN

30-09-F9   (hex)		Bonraybio
900000-9FFFFF     (base 16)		Bonraybio
				4F., No.118, Gongye 9th Rd., Dali Dist.,
				Taichung City  Taiwan  412
				TW

30-09-F9   (hex)		Hurray Cloud Technology Co., Ltd.
000000-0FFFFF     (base 16)		Hurray Cloud Technology Co., Ltd.
				7F., No.407, Sec. 2, Zhongshan Rd., Zhonghe Dist.,
				New Taipei City     235
				TW

84-89-EC   (hex)		Shenzhen Xtooltech Co., Ltd
900000-9FFFFF     (base 16)		Shenzhen Xtooltech Co., Ltd
				10574 Acacia St, Suite D4
				Rancho Cucamonga  CA  91730
				US

C0-83-59   (hex)		ANTS
400000-4FFFFF     (base 16)		ANTS
				88, Simindae-ro, Dongan-Gu
				Anyang    14079
				KR

C0-83-59   (hex)		Gemvax Technology ,. Co.Ltd
100000-1FFFFF     (base 16)		Gemvax Technology ,. Co.Ltd
				30, Techno1-ro, Yuseong-gu, Daejeon
				Daejeon    34016
				KR

9C-F6-DD   (hex)		Foshan Synwit Technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Foshan Synwit Technology Co.,Ltd.
				Room 501, Building 10, Leaguar Science Park, Shishan town, Nanhai
				FoShan  Guangdong  528225
				CN

04-C3-E6   (hex)		DREAMKAS LLC
000000-0FFFFF     (base 16)		DREAMKAS LLC
				Bolshoy  Sampsoniyevskiy pr., 62A, office 2H
				Saint-Petersburg    194044
				RU

04-C3-E6   (hex)		SHANTOU YINGSHENG IMPORT & EXPORT TRADING CO.,LTD.
C00000-CFFFFF     (base 16)		SHANTOU YINGSHENG IMPORT & EXPORT TRADING CO.,LTD.
				Chenghua Industrial Zone，Wenguan Road，Chenghai District
				Shantou City  Guangdong  515800
				CN

3C-42-7E   (hex)		Edit Srl
600000-6FFFFF     (base 16)		Edit Srl
				Via Grotte di Nottola 10
				Cisterna di Latina  Latina  04012
				IT

3C-42-7E   (hex)		UBTECH ROBOTICS CORP
800000-8FFFFF     (base 16)		UBTECH ROBOTICS CORP
				22 Floor, Block C1, Nanshan I Park, No. 1001 Xueyuan Road, Nanshan District,
				Shenzhen  guangdong  518071
				CN

A0-C5-F2   (hex)		Quantlab Financial, LLC
000000-0FFFFF     (base 16)		Quantlab Financial, LLC
				3 Greenway Plaza, Suite 200
				3 Greenway Plaza  TX  77046
				US

B4-4B-D6   (hex)		ShenZhen Comstar Technology Company
500000-5FFFFF     (base 16)		ShenZhen Comstar Technology Company
				Pengnian Science Park Building A 314
				Shenzhen  Guangdong  518040
				CN

B4-4B-D6   (hex)		ELLETA SOLUTIONS LTD
D00000-DFFFFF     (base 16)		ELLETA SOLUTIONS LTD
				Yetsi'at Eropa Street 20
				Hadera    3848427
				IL

3C-42-7E   (hex)		Compal Electronics INC.
B00000-BFFFFF     (base 16)		Compal Electronics INC.
				No.8 , Nandong Road , PingZhen Dist.
				Taoyuan   Taiwan   32455
				TW

A0-19-B2   (hex)		SZBROAD   TECHNOLOGY (HK) CO.,LTMITED
500000-5FFFFF     (base 16)		SZBROAD   TECHNOLOGY (HK) CO.,LTMITED
				FLAT/RM 5 BLK B 14/F WAH HEN COMMERCIAL CENTRE
				 383 HENNESSY ROAD WANCHAI  Hong Kong  00000
				HK

A0-19-B2   (hex)		El Sewedy Electrometer Egypt S.A.E.
100000-1FFFFF     (base 16)		El Sewedy Electrometer Egypt S.A.E.
				Plot No. 154/173 Industrial Zone 2
				ET-6th October City    
				EG

2C-48-35   (hex)		Collatz+Trojan GmbH
A00000-AFFFFF     (base 16)		Collatz+Trojan GmbH
				Borsteler Chaussee85-99a
				Hamburg  Hamburg  22453
				DE

8C-1C-DA   (hex)		Raychem RPG PVT. LTD.
900000-9FFFFF     (base 16)		Raychem RPG PVT. LTD.
				Safari Crossing, Near Halol GIDC, Village - Kanjari, Taluka - Halol
				Halol  Gujarat  389350
				IN

8C-1C-DA   (hex)		ATOL LLC
800000-8FFFFF     (base 16)		ATOL LLC
				Bolshaya Novodmitrovskaya str., 14, build 4
				Moscow    127015
				RU

2C-48-35   (hex)		GEARTECH LTD
400000-4FFFFF     (base 16)		GEARTECH LTD
				R310/312,3/F,Beike Venture Building,No.1077,Nanhai Avenue,Nanshan District
				Shenzhen  Guangdong  518067
				CN

3C-24-F0   (hex)		Shenzhen Bestway Technology Co., Ltd
A00000-AFFFFF     (base 16)		Shenzhen Bestway Technology Co., Ltd
				2nd Floor, Building 9, Jingxuan Industrial Park, East Ring Road, Longhua District,
				Shenzhen  GuangDong  518109
				CN

3C-24-F0   (hex)		GETMOBIT LLC
E00000-EFFFFF     (base 16)		GETMOBIT LLC
				d. 4 str. 2 pom. 137, ul. Programmistov
				Dubna  Moscow  141983
				RU

8C-1C-DA   (hex)		Structura Technology & Innovation
300000-3FFFFF     (base 16)		Structura Technology & Innovation
				via Roveredo 20/B
				Pordenone  PN  33170
				IT

8C-1C-DA   (hex)		GESAS GmbH
100000-1FFFFF     (base 16)		GESAS GmbH
				Pfaelzer Ring 18
				Hockenheim  Baden-Wuerttemberg  68766
				DE

3C-24-F0   (hex)		Authentico Technologies
C00000-CFFFFF     (base 16)		Authentico Technologies
				Erikdahlbergsgatan 4
				Göteborg    41126
				SE

8C-1C-DA   (hex)		T+A elektroakustik GmbH & Co.KG
B00000-BFFFFF     (base 16)		T+A elektroakustik GmbH & Co.KG
				Planckstr. 9-11
				Herford    32052
				DE

48-0B-B2   (hex)		BAJA ELECTRONICS TECHNOLOGY LIMITED
100000-1FFFFF     (base 16)		BAJA ELECTRONICS TECHNOLOGY LIMITED
				403, Unit 3, Building 3, Zhongdian Hi-Tech Park, No.1 Kejiqi Rd.
				Zhuhai  Guangdong  519080
				CN

48-0B-B2   (hex)		M2Lab Ltd.
D00000-DFFFFF     (base 16)		M2Lab Ltd.
				148 Des Voeux Rd Central
				Hong Kong    HK
				HK

48-0B-B2   (hex)		Ridango AS
000000-0FFFFF     (base 16)		Ridango AS
				Pärnu maantee 139E/13
				Tallinn  Harjumaa  11317
				EE

48-0B-B2   (hex)		Beijing MFOX technology Co., Ltd.
E00000-EFFFFF     (base 16)		Beijing MFOX technology Co., Ltd.
				B zone,floor 2,NO.A5 east Rongchang street .BDA (yizhuang) BeiJing
				BeiJing  BeiJing  100176
				CN

0C-73-EB   (hex)		Husty M.Styczen J.Hupert Sp.J.
500000-5FFFFF     (base 16)		Husty M.Styczen J.Hupert Sp.J.
				Rzepakowa 5e
				Krakow  malopolska  31-989
				PL

0C-73-EB   (hex)		Gemini Data Loggers (UK) Limited
000000-0FFFFF     (base 16)		Gemini Data Loggers (UK) Limited
				Scientific House, Terminus Road
				Chichester  West Sussex  PO19 8UJ
				GB

88-5F-E8   (hex)		Lisle Design Ltd
A00000-AFFFFF     (base 16)		Lisle Design Ltd
				New Technology Centre, North Haugh
				St. Andrews  Fife  KY16 9SR
				GB

30-1F-9A   (hex)		YiSheng technology  co.,LTD
600000-6FFFFF     (base 16)		YiSheng technology  co.,LTD
				Xintian road no:71,  F#202
				shenzhen  baoan  518103
				CN

88-5F-E8   (hex)		Shenzhen Xin Kingbrand Enterprises Co.,Ltd     
600000-6FFFFF     (base 16)		Shenzhen Xin Kingbrand Enterprises Co.,Ltd     
				KingBrand Industrial Zone, Nanpu Road,Shang Liao Lin Pikeng,Shajing Town,Baoan District
				Shenzhen     518000
				CN

2C-D1-41   (hex)		Beijing Hexing Chuangxiang Technology Co., Ltd.
900000-9FFFFF     (base 16)		Beijing Hexing Chuangxiang Technology Co., Ltd.
				1306,A block,No.6 Zhichun Road
				Haidian District,  Beijing  100088
				CN

30-1F-9A   (hex)		OLIMEX Ltd
D00000-DFFFFF     (base 16)		OLIMEX Ltd
				2 Pravda
				Plovidv    4000
				BG

88-5F-E8   (hex)		Jungheinrich Norderstedt AG & Co. KG
000000-0FFFFF     (base 16)		Jungheinrich Norderstedt AG & Co. KG
				Lawaetzstr. 9-13
				Norderstedt    22844
				DE

88-5F-E8   (hex)		Opto Engineering
200000-2FFFFF     (base 16)		Opto Engineering
				Circonvallazione Sud, 15
				Mantova    46100
				IT

30-1F-9A   (hex)		Private
900000-9FFFFF     (base 16)		Private

F0-41-C8   (hex)		Shenzhen  Nufilo Electronic Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen  Nufilo Electronic Technology Co., Ltd.
				Tianliao Building West Unit F1315, (New Materials Industrial Park),  Xueyuan Road,  Nanshan District
				Shenzhen   Guangdong  518055
				CN

F0-41-C8   (hex)		Nanchang BlackShark Co.,Ltd.
700000-7FFFFF     (base 16)		Nanchang BlackShark Co.,Ltd.
				Room 319, Jiaoqiao Town Office Building, Economic and Technical development zone, Nanchang City, Jiangxi Province.
				Nanchang    330013
				CN

88-A9-A7   (hex)		Impact Distribution
E00000-EFFFFF     (base 16)		Impact Distribution
				Ter Heidelaan 50a
				Aarschot    3200
				BE

88-A9-A7   (hex)		psb intralogistics GmbH
800000-8FFFFF     (base 16)		psb intralogistics GmbH
				Blocksbergstrasse 145
				Pirmasens    66955
				DE

F0-41-C8   (hex)		AED Engineering GmbH
600000-6FFFFF     (base 16)		AED Engineering GmbH
				Taunusstr. 51
				Munich  Bavaria  80807
				DE

88-A9-A7   (hex)		Solaredge LTD.
100000-1FFFFF     (base 16)		Solaredge LTD.
				Hamada 1
				Herzelia    4673335
				IL

A4-DA-22   (hex)		General Electric Company
000000-0FFFFF     (base 16)		General Electric Company
				Valle del Cedro #1551
				Ciudad Juarez  Chih  32575
				MX

88-A9-A7   (hex)		kimura giken corporation
700000-7FFFFF     (base 16)		kimura giken corporation
				4-9-19 kamiyoga
				Setagaya-ku  Tokyo  158-0098
				JP

A4-DA-22   (hex)		Wyze Labs Inc
200000-2FFFFF     (base 16)		Wyze Labs Inc
				 22522 29TH DR SE L101
				BOTHELL  WA  98021
				US

A4-DA-22   (hex)		Quuppa Oy
E00000-EFFFFF     (base 16)		Quuppa Oy
				Keilaranta 1
				Espoo    02150
				FI

9C-43-1E   (hex)		ST Access Control System Corp.
A00000-AFFFFF     (base 16)		ST Access Control System Corp.
				3F., No. 111 Zhongzheng Rd., Banciao Dist., New Taipei City
				New Taipei City    22054
				TW

DC-E5-33   (hex)		Controls Inc
500000-5FFFFF     (base 16)		Controls Inc
				5204 Portside Drive
				Medina  OH  44256
				US

C4-FF-BC   (hex)		Danego BV
000000-0FFFFF     (base 16)		Danego BV
				Protonenlaan 24
				Uden  NB  5405 NE
				NL

C4-FF-BC   (hex)		Critical Link
700000-7FFFFF     (base 16)		Critical Link
				6712 Brooklawn  Parkway
				Syracuse  null  13211
				US

28-2C-02   (hex)		Shenzhen Neoway Technology Co.,Ltd.
800000-8FFFFF     (base 16)		Shenzhen Neoway Technology Co.,Ltd.
				4F-2#,Lian Jian Science & Industry Park,Huarong Road,Dalang Street,Longhua District
				Shenzhen  Guangdong  518000
				CN

28-2C-02   (hex)		Capintec, Inc.
E00000-EFFFFF     (base 16)		Capintec, Inc.
				7 Vreeland Road
				Florham Park  NJ  07932
				US

28-2C-02   (hex)		SHENZHEN DOMENOR TECHNOLOGY LLC
D00000-DFFFFF     (base 16)		SHENZHEN DOMENOR TECHNOLOGY LLC
				F4, BUILDING A3, SILICON VALLEY POWER TECHNOLOGY PARK, SILI ROAD, KUKENG COMMUNITY, GUANLAN TOWN,LONGHUA DISTRICT
				SHENZHEN  GUANGDONG  518110
				CN

F8-B5-68   (hex)		Solarius
D00000-DFFFFF     (base 16)		Solarius
				Kaeshaldenstrasse 39
				Zurich    8052
				CH

28-2C-02   (hex)		Astronics AES
100000-1FFFFF     (base 16)		Astronics AES
				12950 Willows Rd NE 
				Kirkland  WA  98034
				US

F8-B5-68   (hex)		Package Guard, Inc
600000-6FFFFF     (base 16)		Package Guard, Inc
				2819 33rd ave so
				seattle  WA  98144
				US

18-9B-A5   (hex)		Innominds Software Inc
400000-4FFFFF     (base 16)		Innominds Software Inc
				2055 Junction Ave Suite 122, San Jose CA 95131
				San Jose  CA  95131
				US

40-48-FD   (hex)		Shenzhen Yifang Digital Technology Co., LTD. 
A00000-AFFFFF     (base 16)		Shenzhen Yifang Digital Technology Co., LTD. 
				Building NO. 23, Fifth Region, Baiwangxin  Industrial Park, Songbai Rd. Nanshan, Shenzhen 
				Shenzhen     518108
				CN

38-73-EA   (hex)		Shanghai ZoomSmart Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Shanghai ZoomSmart Technology Co., Ltd.
				ROOM 802, No. 189, Hengxi Road, Pujiang Town, Minhang District, Shanghai PRC
				Shanghai    200000
				CN

EC-9F-0D   (hex)		MAX Technologies
E00000-EFFFFF     (base 16)		MAX Technologies
				2051 Victoria Av.
				St-Lambert  Quebec  J4S1H1
				CA

38-73-EA   (hex)		KingWay Information Co.,Ltd.
100000-1FFFFF     (base 16)		KingWay Information Co.,Ltd.
				3/F Rongxin business organization #56 Jinyan Road
				Fuzhou  Fujian  350000
				CN

EC-9F-0D   (hex)		Waverly Labs Inc.
300000-3FFFFF     (base 16)		Waverly Labs Inc.
				19 Morris Avenue
				Brooklyn  NY  11205
				US

34-D0-B8   (hex)		Kongqiguanjia (Beijing)Technology co.，ltd
E00000-EFFFFF     (base 16)		Kongqiguanjia (Beijing)Technology co.，ltd
				Room 1201,Block A，Building of Fesco，Xidawang Road，Chaoyang district
				Beijing  Beijing  100022
				CN

34-D0-B8   (hex)		NumberFour AG
600000-6FFFFF     (base 16)		NumberFour AG
				Schoenhauser Allee 8
				Berlin    10119
				DE

EC-9F-0D   (hex)		DRB Systems
200000-2FFFFF     (base 16)		DRB Systems
				3245 Pickle Road
				Akron  OH  44312
				US

EC-9F-0D   (hex)		SKS Control Oy
D00000-DFFFFF     (base 16)		SKS Control Oy
				Martinkyläntie 50
				Vantaa    01720
				FI

AC-1D-DF   (hex)		PiOctave Solutions Pvt Ltd
000000-0FFFFF     (base 16)		PiOctave Solutions Pvt Ltd
				#1217, Ground Floor,4th Cross Road, 1st Block, HAL 3rd Stage
				BENGALURU  KARNATAKA  560 075
				IN

AC-1D-DF   (hex)		Duravit AG
E00000-EFFFFF     (base 16)		Duravit AG
				Werderstr. 36
				Hornberg  Baden Wuerttemberg  78132
				DE

34-D0-B8   (hex)		Shenzhen Rikomagic Tech Corp.,Ltd
700000-7FFFFF     (base 16)		Shenzhen Rikomagic Tech Corp.,Ltd
				7021,7F Beifang Junyi Business Center, Lixin South RD,Fuyong Street,Bao'an 
				Shenzhen   Guangdong  518103
				CN

AC-1D-DF   (hex)		Beijing Chunhong Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Beijing Chunhong Technology Co., Ltd.
				Room1502 Hailong Plaza, Zhongguancun, Haidian, Beijing
				Beijing    100000
				CN

34-D0-B8   (hex)		Shenzhen Bao Lai Wei Intelligent Technology Co., L
100000-1FFFFF     (base 16)		Shenzhen Bao Lai Wei Intelligent Technology Co., L
				Longgang Street Baolong Wu Road on the 2nd
				Shenzhen  Guangdong Province  518116
				CN

74-1A-E0   (hex)		SHEN ZHEN YINGJIACHUANG ELECTRONICS TECHNOLOGY CO.,LTD.
B00000-BFFFFF     (base 16)		SHEN ZHEN YINGJIACHUANG ELECTRONICS TECHNOLOGY CO.,LTD.
				Building A,Baishunjia Industrial Park,Guangming New District
				Shenzhen    518107
				CN

74-1A-E0   (hex)		Philips Personal Health Solutions
300000-3FFFFF     (base 16)		Philips Personal Health Solutions
				High Tech Campus, HTC37 floor 0
				Eindhoven    5656 AE
				NL

AC-1D-DF   (hex)		Shenzheng SenseTime Technology Co. Ltd
600000-6FFFFF     (base 16)		Shenzheng SenseTime Technology Co. Ltd
				7F,Haixiang plaza, No.1052 Nanhai Road, Nanshan district
				Shenzhen  Guangdong  518000
				CN

CC-22-37   (hex)		Beijing Safesoft Greatmaker Co.,ltd
500000-5FFFFF     (base 16)		Beijing Safesoft Greatmaker Co.,ltd
				Room 501 ,Unit. D, Jinyujiahua Building ,No. 9 ,Shangdi Three Street , Haidian District 
				Beijing    100144
				CN

CC-22-37   (hex)		Siemens AG Austria
600000-6FFFFF     (base 16)		Siemens AG Austria
				Siemensstrasse 90
				Wien    A-1210
				AT

CC-22-37   (hex)		Shanghai Doit IOT Technology Co.,Ltd.
700000-7FFFFF     (base 16)		Shanghai Doit IOT Technology Co.,Ltd.
				410-412 rooms of 1B business building in NO.1588 ,lianhang road, minhang district
				Shanghai    201100
				CN

CC-22-37   (hex)		MEDCOM sp. z o.o.
000000-0FFFFF     (base 16)		MEDCOM sp. z o.o.
				ul. Jutrzenki 78a
				Warszawa  woj. mazowieckie  02-230
				PL

90-4E-91   (hex)		Shenzhen Cloudynamo Internet Technologies Co.,LTD.
E00000-EFFFFF     (base 16)		Shenzhen Cloudynamo Internet Technologies Co.,LTD.
				NO.502 lingyun Building honglang north second road
				shenzhen    518000
				CN

90-4E-91   (hex)		CommandScape, Inc.
800000-8FFFFF     (base 16)		CommandScape, Inc.
				505 South Flagler Dr, Suite 900
				West Palm Beach  FL  33401
				US

90-4E-91   (hex)		Kaertech Limited
A00000-AFFFFF     (base 16)		Kaertech Limited
				Unit 1601, 21-24 Connaught Road West
				Hong Kong  Sheung Wan  00000
				HK

18-9B-A5   (hex)		Mantra Softech India Pvt Ltd
600000-6FFFFF     (base 16)		Mantra Softech India Pvt Ltd
				B203, Shapath Hexa, S.G. Highway, Sola,
				Ahmedabad  Gujarat  380060
				IN

18-9B-A5   (hex)		Eutron SPA
B00000-BFFFFF     (base 16)		Eutron SPA
				Via Crespi 29/31
				Pradalunga  Bergamo  24020
				IT

2C-27-9E   (hex)		WAYCOM Technology Co.,Ltd
C00000-CFFFFF     (base 16)		WAYCOM Technology Co.,Ltd
				E-605,BLDG 201,A10 Jiuxianqiao North Road Chaoyang District,Beijing 100015,China
				Beijing    100000
				CN

34-29-8F   (hex)		ARC Technology Co., Ltd
E00000-EFFFFF     (base 16)		ARC Technology Co., Ltd
				4F.-2, No.26, Wuquan 2nd Road, 
				Xinzhuang District,  New Taipei City  24892
				TW

34-00-8A   (hex)		Federal Aviation Administration 
500000-5FFFFF     (base 16)		Federal Aviation Administration 
				Atlantic City Int'l Airport, Bldg. 270
				Atlantic City  NJ  08405
				US

34-29-8F   (hex)		BlackEdge Capital
000000-0FFFFF     (base 16)		BlackEdge Capital
				801 West Adams Street, Suite 500
				Chicago    60607
				US

34-00-8A   (hex)		Sithon Technologies SAS
600000-6FFFFF     (base 16)		Sithon Technologies SAS
				115 Rue Claude Chappe
				Plouzane    29280
				FR

34-29-8F   (hex)		Dongguan Kingtron Electronics Tech Co., Ltd
700000-7FFFFF     (base 16)		Dongguan Kingtron Electronics Tech Co., Ltd
				No.3 Fumin North Rd,Shu'an Industrial Park, Humen Town
				Dongguan  Guangdong China  523929
				CN

18-9B-A5   (hex)		Airprotec
200000-2FFFFF     (base 16)		Airprotec
				Avenue de l'Industrie 22
				Braine-l'Alleud    1420
				BE

34-00-8A   (hex)		Globex 99 LTD
300000-3FFFFF     (base 16)		Globex 99 LTD
				Trakia bl. 240
				Plovdiv    4000
				BG

0C-EF-AF   (hex)		Hubei Century Network Technology Co., Ltd
B00000-BFFFFF     (base 16)		Hubei Century Network Technology Co., Ltd
				9-11th floor, B7, FinancialHarbour, NO.77, Guanggu Avenue, East Lake New Technology Development Zone
				Wuhan  Hubei  430074
				CN

34-00-8A   (hex)		ZQAM Communications
100000-1FFFFF     (base 16)		ZQAM Communications
				3F., No.6, Innovation Road II, Science Park, 
				Hsinchu    30076
				TW

28-F5-37   (hex)		Matricx Singapore Pte Ltd
C00000-CFFFFF     (base 16)		Matricx Singapore Pte Ltd
				2nd Flr. 2 Bldg., Detai Technology Industrial Park, Huarong Road No. 460, Dalang, Longhua district,
				Shenzhen  Guangdong  518000
				CN

28-F5-37   (hex)		Unicair Communication Tec Co., Ltd.
200000-2FFFFF     (base 16)		Unicair Communication Tec Co., Ltd.
				深圳市宝安区西乡航空路与顺昌路交汇处梧桐岛1号楼8楼
				ShenZhen    418100
				CN

78-D8-00   (hex)		Kverneland Group Mechatronics
000000-0FFFFF     (base 16)		Kverneland Group Mechatronics
				Hoofdweg 1278
				Nieuw-Vennep  Noord Holland  NL-2153 LR
				NL

78-D8-00   (hex)		Alango Technologies Ltd
600000-6FFFFF     (base 16)		Alango Technologies Ltd
				Etgar 2, Carmel Biulding 1rd floor
				Tirat Carmel  Haifa  39100
				IL

28-F5-37   (hex)		Phyn LLC
400000-4FFFFF     (base 16)		Phyn LLC
				1855 Del Amo Blvd
				Torrance  CA  90501
				US

78-D8-00   (hex)		Shanghai Espacetime Technology Co.,Ltd.
200000-2FFFFF     (base 16)		Shanghai Espacetime Technology Co.,Ltd.
				Room 1202-A ,NO.570 , Shengxia Road , Pudong
				Shanghai    200120
				CN

7C-BA-CC   (hex)		Maco Lighting Pty. Ltd.
200000-2FFFFF     (base 16)		Maco Lighting Pty. Ltd.
				5/9 Stockwell Place
				Archerfield  Queensland  4108
				AU

7C-BA-CC   (hex)		Collinear Networks Inc.
800000-8FFFFF     (base 16)		Collinear Networks Inc.
				2901 Tasman Drive
				Santa Clara  CA  95054
				US

78-D8-00   (hex)		NimbeLink Corp
700000-7FFFFF     (base 16)		NimbeLink Corp
				3131 Fernbrook LN N, Ste 100
				Plymouth  MN  55447
				US

F8-8A-3C   (hex)		withus
900000-9FFFFF     (base 16)		withus
				Rua Dr. Mario Sacramento Ed. Colombo II N22
				Aveiro    3810-106
				PT

7C-BA-CC   (hex)		TGT Limited
000000-0FFFFF     (base 16)		TGT Limited
				Flat/Rm 1003 10/F, Witty Commercial Building, 1A-1L Tung Choi Street, Hong Kong 
				HongKong    529060
				HK

F8-8A-3C   (hex)		THK Co.,LTD.
D00000-DFFFFF     (base 16)		THK Co.,LTD.
				4-9-16 Higashikoujiya
				Ota  Tokyo  1440033
				JP

F8-8A-3C   (hex)		EXCETOP TECHNOLOGY (BEIJING) CO., LTD.
C00000-CFFFFF     (base 16)		EXCETOP TECHNOLOGY (BEIJING) CO., LTD.
				A03, 9th Floor, Horizon International Tower, No.6, Zhichun Road, Haidian District
				Beijing    100191
				CN

4C-65-A8   (hex)		Qingping Technology (Beijing) Co., Ltd.
D00000-DFFFFF     (base 16)		Qingping Technology (Beijing) Co., Ltd.
				Room 401, Block B, Fangheng Times Square, No. 10 Wangjing Street, Chaoyang District
				Beijing    100102
				CN

A0-C5-F2   (hex)		Shenzhen Feima Robotics Technology Co.,Ltd
300000-3FFFFF     (base 16)		Shenzhen Feima Robotics Technology Co.,Ltd
				1/f,16 ,Zhiheng Industrial Park, Nantou Second Road, Nantou Street, Nanshan District
				Shenzhen  Guangdong  518000
				CN

F0-23-B9   (hex)		Raysgem Electronics and Technology Co.Ltd
200000-2FFFFF     (base 16)		Raysgem Electronics and Technology Co.Ltd
				4th Floor, Block2 HuafengIndustrial park for Oversea Students Baolong 1st Road Longgang 
				Shenzhen  Guangdong  518118
				CN

8C-14-7D   (hex)		Reynaers Aluminium
C00000-CFFFFF     (base 16)		Reynaers Aluminium
				Oude Liersebaan 266
				Duffel    2570
				BE

8C-14-7D   (hex)		Remotec Technology Limited
300000-3FFFFF     (base 16)		Remotec Technology Limited
				FLAT/RM 2 , BLK 2 , 2/F , TONIC INDUSTRIAL CENTRE , 19 LAM HING STREET , KOWLOON BAY 
				HONG KONG    00000
				HK

8C-14-7D   (hex)		V2 S.p.A.
800000-8FFFFF     (base 16)		V2 S.p.A.
				Corso Principi di Piemonte 65/67
				Racconigi  Cuneo  12035
				IT

A0-C5-F2   (hex)		ShenZhen JuWangShi Tech
600000-6FFFFF     (base 16)		ShenZhen JuWangShi Tech
				Room 1701 Unit B2,Kexing Science Park,Keyuan Road
				ShenZhen  NanShan  518057
				CN

A0-C5-F2   (hex)		Spacepath Communications Ltd
500000-5FFFFF     (base 16)		Spacepath Communications Ltd
				Unit 4, Bartley Point, Osborn Way
				Hook, Hampshire    RG27 9GX
				GB

8C-14-7D   (hex)		Agilent S.p.A
200000-2FFFFF     (base 16)		Agilent S.p.A
				Via.flli Varian 54
				Leini  Torino  10040
				IT

8C-14-7D   (hex)		UrbanHello
700000-7FFFFF     (base 16)		UrbanHello
				13 rue Saint Antoine
				Paris    75004
				FR

F0-23-B9   (hex)		Transcend Building Automation control network corporation
700000-7FFFFF     (base 16)		Transcend Building Automation control network corporation
				15F. No.145 Ren’ai Rd. Xizhi Dist.
				New Taipei City  Taiwan  22164
				TW

04-71-4B   (hex)		Armstrong Fluid Technology
600000-6FFFFF     (base 16)		Armstrong Fluid Technology
				23 Bertrand Avenue
				Toronto  Ontario  M1L2P3
				CA

60-D7-E3   (hex)		 LongSung Technology (Shanghai) Co.,Ltd.   
900000-9FFFFF     (base 16)		 LongSung Technology (Shanghai) Co.,Ltd.   
				 Room 606, Block B, Bldg. 1, No. 3000 Longdong Avenue., Zhangjiang Hi-Tech Park, Pudong District
				ShangHai    201203
				CN

04-71-4B   (hex)		Omylis Pte Ltd
700000-7FFFFF     (base 16)		Omylis Pte Ltd
				150, South Bridge Road #06-04B, Fook Hai Building
				Singapore    058727
				SG

60-D7-E3   (hex)		Novo innovations Ltd
200000-2FFFFF     (base 16)		Novo innovations Ltd
				Westwood way
				Westwood business park  Coventry  Cv4 8lg
				GB

08-ED-02   (hex)		SANGO ELECTRONICS CO
600000-6FFFFF     (base 16)		SANGO ELECTRONICS CO
				RM 253,2/F,BLOCK A, CAMBRIDGE  PLAZA,188,SANWAN ROAD,  SHEUNG SHUI,HONG KONG 
				HongKong     518131
				CN

08-ED-02   (hex)		Jiangsu Logread Network Technology Co., LTD.
300000-3FFFFF     (base 16)		Jiangsu Logread Network Technology Co., LTD.
				No. 100 # 9, Shu Gang West Road, HanJiang Area, 
				Yangzhou   Jiangsu  225100
				CN

08-ED-02   (hex)		Vigitron Inc.
500000-5FFFFF     (base 16)		Vigitron Inc.
				7810 Trade Street, STE 100
				San Diego  CA  92121
				US

08-ED-02   (hex)		Fio Corporation
400000-4FFFFF     (base 16)		Fio Corporation
				111 Queen Street East, Suite 500
				Toronto  ON  M5C 1S2
				CA

08-ED-02   (hex)		Victiana SRL
A00000-AFFFFF     (base 16)		Victiana SRL
				Strada A. Hasdeu, nr. 66/3
				Chisinau    MD-2001
				MD

60-D7-E3   (hex)		Phase One A/S
700000-7FFFFF     (base 16)		Phase One A/S
				Roskildevej 39
				Frederiksberg    2000
				DK

98-AA-FC   (hex)		Shenzhen Hubsan Technology Co.，LTD.
700000-7FFFFF     (base 16)		Shenzhen Hubsan Technology Co.，LTD.
				 Xuefu Road, Nanshan District, 
				13th Floor, Bldg 1C, Shenzhen Software Industry Base, Xuefu Road, Nanshan District,  Guangdong  518054
				CN

98-AA-FC   (hex)		SPM Instrument AB
500000-5FFFFF     (base 16)		SPM Instrument AB
				Box 504
				Strängnäs    SE-64525
				SE

A4-11-63   (hex)		Viloc
C00000-CFFFFF     (base 16)		Viloc
				Langestraat, 221
				Zandhoven  België  2240
				BE

1C-C0-E1   (hex)		Nitto Seiko
C00000-CFFFFF     (base 16)		Nitto Seiko
				shiroyama-cho 2banti
				Ayabe-si  Kyoto-hu  623-0003
				JP

A4-11-63   (hex)		Adetel Equipment
000000-0FFFFF     (base 16)		Adetel Equipment
				3200 rue guénette
				Montréal  Québec  H4S 2G5
				CA

A4-11-63   (hex)		tinylogics
E00000-EFFFFF     (base 16)		tinylogics
				St John's Innovation Centre, Cambridge
				London    CB4 0WS
				GB

A4-11-63   (hex)		ISE GmbH
A00000-AFFFFF     (base 16)		ISE GmbH
				Osterstrasse 15
				Oldenburg    26122
				DE

A4-11-63   (hex)		Allgo Tech. (Beijing) Co.,Ltd
200000-2FFFFF     (base 16)		Allgo Tech. (Beijing) Co.,Ltd
				Room 6012 Innovation Building ,NO.101 Southwest of 4th Ring Road, Fengtai District
				Beijing  Beijing  100070
				CN

14-4F-D7   (hex)		Shenzhen V-Streaming Technology Co., Ltd.
700000-7FFFFF     (base 16)		Shenzhen V-Streaming Technology Co., Ltd.
				Room610, LangShanGe Building, Yugu Hi-Tech Park, Liuxin Road 1183, Nanshan District
				Shenzhen  Guangdong  518000
				CN

1C-A0-D3   (hex)		LYT inc.
C00000-CFFFFF     (base 16)		LYT inc.
				440, North Wolfe Road
				Sunnyvale  CA  94085
				US

1C-A0-D3   (hex)		Desarrollos y Soluciones Guinea I+D S.L.
800000-8FFFFF     (base 16)		Desarrollos y Soluciones Guinea I+D S.L.
				Avda. de los Trabajadores nº2 1ªPlanta
				Illescas  Toledo  45200
				ES

A4-11-63   (hex)		INTER CONTROL Hermann Köhler Elektrik GmbH & Co.KG
100000-1FFFFF     (base 16)		INTER CONTROL Hermann Köhler Elektrik GmbH & Co.KG
				Schafhofstrasse 30
				Nuernberg    90411
				DE

38-FD-FE   (hex)		New Garden Co., Ltd.
C00000-CFFFFF     (base 16)		New Garden Co., Ltd.
				2F, NO.58, Xingshan Rd., Neihu.,
				Taipei    114
				TW

A4-11-63   (hex)		AlterG, Inc.
400000-4FFFFF     (base 16)		AlterG, Inc.
				48438 Milmont Drive
				Fremont  CA  94538
				US

1C-A0-D3   (hex)		Jabil circuit italia srl
100000-1FFFFF     (base 16)		Jabil circuit italia srl
				Via Giovanni Francesco Maggio'  Agglomerato Industriale
				marcianise  caserta  81025
				IT

1C-A0-D3   (hex)		DSM Messtechnik GmbH
A00000-AFFFFF     (base 16)		DSM Messtechnik GmbH
				Dieselstrasse 16
				Aalen  Baden-Wuerttemberg  73431
				DE

1C-A0-D3   (hex)		ERATO (HK) Corporation Limited
D00000-DFFFFF     (base 16)		ERATO (HK) Corporation Limited
				Unit P,8th floor, Kaiser Estate 3rd Phase, No,11 Hok Yuen Street, Hung Hom
				Kowloon  Hong Kong  999077
				HK

58-E8-76   (hex)		DivioTec Inc.
600000-6FFFFF     (base 16)		DivioTec Inc.
				19F-1A, No.97, Sec. 4, ChongXin Rd., San Chong Dist., 
				New Taipei     24161
				TW

50-A4-D0   (hex)		ZHENG DIAN ELECTRONICS LIMITED
B00000-BFFFFF     (base 16)		ZHENG DIAN ELECTRONICS LIMITED
				11 Xianghe Street, Xinmin, Changan
				Dongguan  Guangdong  523879
				CN

50-A4-D0   (hex)		Beijing ANTVR Technology Co., LTD
100000-1FFFFF     (base 16)		Beijing ANTVR Technology Co., LTD
				4th floor of Building C, Lenovo Beijing Innovation Center, No. 6 Shangdi West Rd., Haidian Distr., Beijing 100085, China
				Beijing  Beijing  100085
				CN

40-F3-85   (hex)		Lennox International Incorporated
600000-6FFFFF     (base 16)		Lennox International Incorporated
				1600 Metrocrest Drive
				Carrollton  TX  75006
				US

80-7B-85   (hex)		Chendu Ningshui Technology Co.,Ltd
700000-7FFFFF     (base 16)		Chendu Ningshui Technology Co.,Ltd
				Baiyun Road ,xindu District ,ChengDu city, Sichuan Province ,China
				Chengdu  Sichuan  610500
				CN

40-F3-85   (hex)		Fast Precision Technologies Co. Ltd.
900000-9FFFFF     (base 16)		Fast Precision Technologies Co. Ltd.
				4th Floor, Yang Tian Bldg., Chuang Ye Er Road & Yang Tian Road, Bao An District
				Shenzhen  Guangdong  518101
				CN

50-A4-D0   (hex)		Seneco A/S
200000-2FFFFF     (base 16)		Seneco A/S
				Bøgekildevej 4
				Hasselager  Danmark  8361
				DK

34-04-9E   (hex)		Pebble Technology
700000-7FFFFF     (base 16)		Pebble Technology
				900 Middlefield Road, Floor 5
				Redwood City  CA  94063
				US

50-A4-D0   (hex)		PointGrab
600000-6FFFFF     (base 16)		PointGrab
				4 Haharash Str
				Hod Hasharon    45240
				IL

34-04-9E   (hex)		EFD Induction
200000-2FFFFF     (base 16)		EFD Induction
				Boleveien 10
				skien    3724
				NO

34-04-9E   (hex)		i3 International Inc.
A00000-AFFFFF     (base 16)		i3 International Inc.
				780 Birchmount Road
				Scarborough  Ontario  M1K5H4
				CA

A4-58-0F   (hex)		BLOKS. GmbH
200000-2FFFFF     (base 16)		BLOKS. GmbH
				Agnes-Pockels-Bogen 1
				Munich    80992
				DE

A4-58-0F   (hex)		INNOPRO
000000-0FFFFF     (base 16)		INNOPRO
				Building 33, Dahe Industrial Zone, Huanguan South Rd., Guanlan Street,
				ShenZhen   GuangDong  518100
				CN

40-ED-98   (hex)		GUANGZHOU AURIC INTELLIGENT TECHNOLOGY CO.,LTD.
800000-8FFFFF     (base 16)		GUANGZHOU AURIC INTELLIGENT TECHNOLOGY CO.,LTD.
				Room 209, No. 115, JiuFoJianShe Road, Sino-Singapore Guangzhou Knowledge City, Huangpu District, Guangzhou
				Guangzhou  Guangdong  510555
				CN

40-ED-98   (hex)		Knox Company
300000-3FFFFF     (base 16)		Knox Company
				1601 W DEER VALLEY RD
				Phoenix  AZ  85027-2112
				US

40-ED-98   (hex)		Kendrion Kuhnke Automation GmbH
400000-4FFFFF     (base 16)		Kendrion Kuhnke Automation GmbH
				Luetjenburger Strasse 101
				Malente  SH  23714
				DE

50-0B-91   (hex)		Machfu, Inc.
900000-9FFFFF     (base 16)		Machfu, Inc.
				20271 Goldenrod Ln
				Germantown  MD  20876
				US

50-0B-91   (hex)		jiangsu zhongling high-tech CO.,LTD.
500000-5FFFFF     (base 16)		jiangsu zhongling high-tech CO.,LTD.
				NO.168 shugangdong road yangzhou city jiangsu china
				yangzhou    225000
				CN

50-0B-91   (hex)		New Audio LLC
A00000-AFFFFF     (base 16)		New Audio LLC
				132 W 31st Street Suite 701
				New York  NY  10001
				US

7C-CB-E2   (hex)		Shanghai Institute of Applied Physics, Chinese Academy of Sciences
A00000-AFFFFF     (base 16)		Shanghai Institute of Applied Physics, Chinese Academy of Sciences
				 239 Zhang Heng Road, Pudong New District
				Shanghai  Shanghai  201203
				CN

50-0B-91   (hex)		SPD Development Company Ltd
100000-1FFFFF     (base 16)		SPD Development Company Ltd
				Stannard Way, Priory Business Park
				Bedford    MK44 3UP
				GB

50-0B-91   (hex)		thumbzup UK Limited
B00000-BFFFFF     (base 16)		thumbzup UK Limited
				6th Floor, 94 Wigmore Street
				London    W1U 3RF
				GB

48-65-EE   (hex)		VideoStitch, Inc
900000-9FFFFF     (base 16)		VideoStitch, Inc
				4677 Old Ironsides Dr, Suite 320
				Santa Clara  CA  95054
				US

48-65-EE   (hex)		CaptionCall
200000-2FFFFF     (base 16)		CaptionCall
				4215 Riverboat Road
				Salt Lake City  UT  84123
				US

24-4E-7B   (hex)		Cyber1st
800000-8FFFFF     (base 16)		Cyber1st
				Meteor Centre, Mansfield Road
				Derby  Derbyshire  DE21 4SY
				GB

24-4E-7B   (hex)		Owasys Advanced Wireless Devices
600000-6FFFFF     (base 16)		Owasys Advanced Wireless Devices
				Parque Tecnologico, 207-B
				Zamudio  Vizcaya  E-48170
				ES

48-65-EE   (hex)		Shenzhen Inpor cloud Computing Co., Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Inpor cloud Computing Co., Ltd.
				15th Floor, Building B4, Kexing Science Park, Nanshan District zip
				guangdong    518000
				CN

48-65-EE   (hex)		DNV GL
C00000-CFFFFF     (base 16)		DNV GL
				Utrechtseweg 310
				Arnhem    6812 AR
				NL

1C-C0-E1   (hex)		Kids Wireless Inc
500000-5FFFFF     (base 16)		Kids Wireless Inc
				200 Bathurst Dr.
				Waterloo  Ontario  N2V 2L7
				CA

1C-C0-E1   (hex)		Hangzhou Kaierda Electric Welding Machine Co.,Ltd
100000-1FFFFF     (base 16)		Hangzhou Kaierda Electric Welding Machine Co.,Ltd
				#6 Kenhui Five Road,Xiaoshan Economic & Technology Development Zone
				Hangzhou    311232
				CN

1C-C0-E1   (hex)		Yun Yang Fire Safety Equipment Co.,Ltd.
E00000-EFFFFF     (base 16)		Yun Yang Fire Safety Equipment Co.,Ltd.
				No.11-4, Wanjin Rd., Dashe Dist., 
				Kaohsiung City     815
				TW

AC-64-DD   (hex)		Kpnetworks Ltd.
600000-6FFFFF     (base 16)		Kpnetworks Ltd.
				4-5-11-10F Shiba
				Minato-ku  Tokyo  108-0014
				JP

AC-64-DD   (hex)		SHANGHAI ZTE TECHNOLOGIES CO.,LTD
500000-5FFFFF     (base 16)		SHANGHAI ZTE TECHNOLOGIES CO.,LTD
				Bibo Road, Shanghai Pudong Zhangjiang Hi-Tech Park, Building No. 889, ZTE H Block 6F
				SHANGHAI  SHANGHAI  201210
				CN

4C-E1-73   (hex)		jvi
A00000-AFFFFF     (base 16)		jvi
				Ettenbergstrasse 19
				Deckenpfronn    75392
				DE

AC-64-DD   (hex)		Jia-Teng
000000-0FFFFF     (base 16)		Jia-Teng
				4F., No.417, Ruiguang Rd., Neihu Dist., Taipei City 114, Taiwan (R.O.C)
				Taipei  Taipei  114
				TW

AC-64-DD   (hex)		Micro Connect Pty Ltd
900000-9FFFFF     (base 16)		Micro Connect Pty Ltd
				22 Gardenia Place
				FOREST GLEN  QLD  4556
				AU

4C-E1-73   (hex)		Lenovo Data Center Group
200000-2FFFFF     (base 16)		Lenovo Data Center Group
				8001 Development Dr
				Morrisville  NC   27560
				US

4C-E1-73   (hex)		Ersúles Limited
700000-7FFFFF     (base 16)		Ersúles Limited
				Unit 17 Sandyford Office Park
				Dublin     D18 NP77
				IE

38-3A-21   (hex)		Foresight Sports
A00000-AFFFFF     (base 16)		Foresight Sports
				9965 Carroll Canyon Road
				San Diego   CA  92131
				US

38-3A-21   (hex)		Alicat Scientific
800000-8FFFFF     (base 16)		Alicat Scientific
				7641 N Business Park Dr
				Tucson  AZ  85743
				US

F8-1D-78   (hex)		Dongguan Shun Hing Plastics Limited
000000-0FFFFF     (base 16)		Dongguan Shun Hing Plastics Limited
				No.11,13,15,Zhongfang Industrial Road,Shatou,Changan Town
				Dongguan City  Guangdong  523861
				CN

F8-1D-78   (hex)		Zengge Co., Limited
600000-6FFFFF     (base 16)		Zengge Co., Limited
				3/F, B Building, Second Laowei Industrial Zone, Longhua District
				Shenzhen  Guangdong  518109
				CN

70-F8-E7   (hex)		CUAV
E00000-EFFFFF     (base 16)		CUAV
				zengcheng city xiapu
				guangzhou  guangdong  511340
				CN

70-F8-E7   (hex)		Beijing Eehuu Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Beijing Eehuu Technology Co.,Ltd.
				Room 2010, 3rd floor, Building #10, No.39 Sanlihe Road, Haidian District, Beijing, China
				BEIJING  Beijing  10000
				CN

70-F8-E7   (hex)		NST Technology Limited Co.,Ltd.
700000-7FFFFF     (base 16)		NST Technology Limited Co.,Ltd.
				1F,ABuilding,Juxie Zuo,No.18 Zhenze Road, 
				wuxi  Jiangsu  214073
				CN

70-F8-E7   (hex)		CLIP Inc.
400000-4FFFFF     (base 16)		CLIP Inc.
				4－5－18,Hommachi,Chuo-ku
				Osaka-city  Osaka-fu  541-0053
				JP

84-E0-F4   (hex)		Hangzhou Nationalchip Science & Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Hangzhou Nationalchip Science & Technology Co.,Ltd.
				5-6th Floor, Innovation Mansion East Software Park,90# Wensan Road
				Hangzhou  Zhejiang  310012
				CN

70-F8-E7   (hex)		System-on-Chip engineering
D00000-DFFFFF     (base 16)		System-on-Chip engineering
				Jose María Escuza 23 Entreplanta Dcha D
				Bilbao  Bizkaia  ES48013
				ES

70-F8-E7   (hex)		Photonfocus AG
B00000-BFFFFF     (base 16)		Photonfocus AG
				Bahnhofplatz 10
				Lachen  SZ  8853
				CH

84-E0-F4   (hex)		SHENZHEN HCN.ELECTRONICS CO.,LTD.
900000-9FFFFF     (base 16)		SHENZHEN HCN.ELECTRONICS CO.,LTD.
				8F, Block C3, Nanshan I Park, No.1001 Xueyuan Road, Nanshan District
				shenzhen  guangdong  518040
				CN

84-E0-F4   (hex)		Logos01 Srl
D00000-DFFFFF     (base 16)		Logos01 Srl
				Via Pertini 23
				Marmirolo  MN  46045
				IT

84-E0-F4   (hex)		PetroInTrade
400000-4FFFFF     (base 16)		PetroInTrade
				Engelsa 71
				Saint-Peterburg    194214
				RU

C0-D3-91   (hex)		Fuzhou Jinshi Technology Co.,Ltd.
000000-0FFFFF     (base 16)		Fuzhou Jinshi Technology Co.,Ltd.
				Block A, Building 39#，District D, Software Park
				Fuzhou  Fujian Province  350003
				CN

C0-D3-91   (hex)		Vernier Software & Technology
400000-4FFFFF     (base 16)		Vernier Software & Technology
				13979 SW Millikan Way
				Beaverton  OR  97005
				US

5C-F2-86   (hex)		Shenzhen VST Automotive Electronics Co., LTD
900000-9FFFFF     (base 16)		Shenzhen VST Automotive Electronics Co., LTD
				3 floor,1Building, No.3 West of ShangXue Science and technology park, Bantian town, LongGang District
				ShenZhen  Guangdong  518100
				CN

C0-D3-91   (hex)		Ernitec
600000-6FFFFF     (base 16)		Ernitec
				Tempovej 41
				Ballerup    2750
				DK

58-E8-76   (hex)		Beijing Perabytes IS Technology Co., Ltd
100000-1FFFFF     (base 16)		Beijing Perabytes IS Technology Co., Ltd
				2F, Office Building, No. 2 Yard, Longxiang Printing-plate Group, North of Huilongguan Village, Huilongguan Town, ChangPing District，Beijing 102208, P.R. China
				Beijing  Beijing  102208
				CN

58-E8-76   (hex)		 Baoruh Electronic Co., Ltd.
E00000-EFFFFF     (base 16)		 Baoruh Electronic Co., Ltd.
				o.285, Dingciang Street, Kaohsiung, 80790 Taiwan.
				 Kaohsiung    80790 
				TW

58-E8-76   (hex)		Coala Life AB
200000-2FFFFF     (base 16)		Coala Life AB
				Riddargatan 18
				Stockholm    11451
				SE

58-E8-76   (hex)		Chronos Technology Ltd.
700000-7FFFFF     (base 16)		Chronos Technology Ltd.
				Stowfield House
				Lydbrook  Gloucestershire  GL17 9PD
				GB

F0-AC-D7   (hex)		Simprints Technology Ltd
C00000-CFFFFF     (base 16)		Simprints Technology Ltd
				The Chesterton Tower
				Cambridge    CB4 1DZ
				GB

B0-C5-CA   (hex)		SHENZHEN KTC TECHNOLOGY GROUP 
700000-7FFFFF     (base 16)		SHENZHEN KTC TECHNOLOGY GROUP 
				Northern Wuhe Road,Banxuegang Industry Area,Buji,Shenzhen,China
				Shenzhen  Guangdong  518129
				CN

F0-AC-D7   (hex)		U3storage Technologies Co., Ltd
900000-9FFFFF     (base 16)		U3storage Technologies Co., Ltd
				information Road No. 26 , Haidian District 
				BEIJING    100085
				CN

28-36-38   (hex)		SHENZHEN GOSPELL SMARTHOME ELECTRONIC CO., LTD.
200000-2FFFFF     (base 16)		SHENZHEN GOSPELL SMARTHOME ELECTRONIC CO., LTD.
				Block F10~13, F518 Idea Land, Bao Yuan Road, Baoan, Shenzhen
				Shenzhen  Guangdong  518102
				CN

28-36-38   (hex)		Sabinetek
300000-3FFFFF     (base 16)		Sabinetek
				NO.1406  Hong Yuan Building  ,Jiu Xian Qiao Road A 4,Chao Yang Beijing China
				Beijing  Beijing  100000
				CN

78-CA-83   (hex)		Hubei Boyuan Zhijia Network Media Co. Ltd.
D00000-DFFFFF     (base 16)		Hubei Boyuan Zhijia Network Media Co. Ltd.
				Wuhan City, Hubei City, Optics Valley Province, Optics Valley 77, city, financial port A3 12
				Wuhan  Hubei  42000
				CN

8C-19-2D   (hex)		Elcon AB
E00000-EFFFFF     (base 16)		Elcon AB
				Hyttrisvagen 27
				Nyhammar    77014
				SE

8C-19-2D   (hex)		Greenfield Technology
300000-3FFFFF     (base 16)		Greenfield Technology
				1 bis rue marcel paul
				massy    91300
				FR

D0-D9-4F   (hex)		APPOTRONICS CO., LTD
E00000-EFFFFF     (base 16)		APPOTRONICS CO., LTD
				4th Floor,SZICC,NO.1089,Chaguang Road,Nanshan District, Shenzhen, China
				Shenzhen  Guangdong  518000
				CN

CC-D3-1E   (hex)		Shenzhen Decnta Technology Co.,LTD.
700000-7FFFFF     (base 16)		Shenzhen Decnta Technology Co.,LTD.
				F13,No.02,Building Shangqi,Nanhaidadao 4050 Nanshan District,Shenzhen,P.R.China
				shenzhen  Guangdong  518057
				CN

C4-7C-8D   (hex)		Star2Star Communications, LLC
200000-2FFFFF     (base 16)		Star2Star Communications, LLC
				600 Tallevast Road, Suite 202
				Sarasota  FL  34243
				US

CC-D3-1E   (hex)		NTmore.Co.,Ltd
500000-5FFFFF     (base 16)		NTmore.Co.,Ltd
				38, Heungan-daero 427 beon-gil, Dongan-gu
				Anyang  Gyeonggi  431-801
				KR

CC-D3-1E   (hex)		inoage GmbH
800000-8FFFFF     (base 16)		inoage GmbH
				Wiener Str. 56
				Dresden    01219
				DE

C4-7C-8D   (hex)		Anhui GuangXing Linked-Video Communication Technology Co, Ltd.
D00000-DFFFFF     (base 16)		Anhui GuangXing Linked-Video Communication Technology Co, Ltd.
				Floor 6, Block B, Idiopathic Information Technology Port, Kefeng Road No. 2, Nanshan District
				Shenzhen  Guangdong  518057
				CN

68-91-D0   (hex)		solvimus GmbH
800000-8FFFFF     (base 16)		solvimus GmbH
				Ehrenbergstr. 11
				Ilmenau    98693
				DE

68-91-D0   (hex)		Spraying Systems Co.
C00000-CFFFFF     (base 16)		Spraying Systems Co.
				North Ave. and Schmale Road P.O. Box 7900 
				Wheaton  IL  60187-7901
				US

68-91-D0   (hex)		Fuzhou x-speed information technology Co.,Ltd.
D00000-DFFFFF     (base 16)		Fuzhou x-speed information technology Co.,Ltd.
				 tianewan 30#1601 Pushang Load,Cangshan District,
				Fuzhou  Fujian  350008
				CN

E0-B6-F5   (hex)		Moog Crossbow
B00000-BFFFFF     (base 16)		Moog Crossbow
				1421 McCarthy Blvd
				Milpitas  CA  95035
				US

E0-B6-F5   (hex)		START TODAY CO.,LTD.
100000-1FFFFF     (base 16)		START TODAY CO.,LTD.
				WBG Malibu West 16 Floor 2-6-1 Nakase Mihama-ku, Chiba
				Chiba  Chiba  261-7116
				JP

50-FF-99   (hex)		metraTec GmbH
A00000-AFFFFF     (base 16)		metraTec GmbH
				Niels-Bohr-Str. 5
				Magdeburg  Sachsen-Anh.  39106
				DE

50-FF-99   (hex)		Dolphin Concepts Limited
800000-8FFFFF     (base 16)		Dolphin Concepts Limited
				A 10, Unit B-E
				11/F, Genesis, 33-35 Wong Chuk Hang Road,  Hong Kong  11111
				HK

98-6D-35   (hex)		SHENZHEN FISE TECHNOLOGY HOLDING CO.,LTD.
200000-2FFFFF     (base 16)		SHENZHEN FISE TECHNOLOGY HOLDING CO.,LTD.
				No.6 Building, Longfu Industrial Area, Huarong Road, Tongsheng Community, Dalang Street, Longhua New District, Shenzhen, Guangdong, China
				shenzhen  guangdong  518000
				CN

98-6D-35   (hex)		INTECH
B00000-BFFFFF     (base 16)		INTECH
				1F No. 45, Wanghai Road / Software Park Phase Ⅱ, Xiamen, China
				Xiamen  Fujian  361008
				CN

98-6D-35   (hex)		BAYCOM OPTO-ELECTRONICS TECHNOLGY CO., LTD.
E00000-EFFFFF     (base 16)		BAYCOM OPTO-ELECTRONICS TECHNOLGY CO., LTD.
				3F, NO.9, INDUSTRIAL EAST 9TH RD. HSINCHU SCIENCE PARK, HSIN-CHU CITY, TAIWAN, R.O.C.
				HSIN-CHU    30075
				TW

98-6D-35   (hex)		iWave Japan, Inc.
A00000-AFFFFF     (base 16)		iWave Japan, Inc.
				8F-B,Kannai Sumiyoshi Building,3-29 Sumiyoshi-Cho,Naka-Ku,
				Yokohama, Kanagawa    231-0013
				JP

10-07-23   (hex)		Diginet Control Systems Pty Ltd
200000-2FFFFF     (base 16)		Diginet Control Systems Pty Ltd
				96-112 Gow Street
				Padstow  New South Wales  2211
				AU

7C-47-7C   (hex)		Hangzhou Yiyitaidi Information Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Hangzhou Yiyitaidi Information Technology Co., Ltd.
				#9 Jiuhuan Road, Building 1B208, Jianggan District
				Hangzhou  Zhejiang  310019
				CN

5C-F2-86   (hex)		Itron UK Limited
B00000-BFFFFF     (base 16)		Itron UK Limited
				Harfreys Road , Harfreys Ind. Estate
				Great Yarmouth    NR31 0LS
				GB

38-FD-FE   (hex)		WAYTONE (BEIIJNG) COMMUNICATIONS CO.,LTD
100000-1FFFFF     (base 16)		WAYTONE (BEIIJNG) COMMUNICATIONS CO.,LTD
				ROOM 201B,KESHI BUILDING,NO.28 XINXI ROAD HAIDIAN BEIJING,P.R.CHINA 
				Beijing  Beijing  100085 
				CN

7C-47-7C   (hex)		POWERLAND LIMITED
200000-2FFFFF     (base 16)		POWERLAND LIMITED
				7F, Buiding A2, ZhongTai Information Industry Park, DeZheng Road, ShiYan Street.
				ShenZhen  GuangDong  518108
				CN

38-B8-EB   (hex)		Yellowbrick Data, Inc.
D00000-DFFFFF     (base 16)		Yellowbrick Data, Inc.
				250 Cambridge Av.,  Suite 201
				Palo Alto  CA  94306
				US

38-FD-FE   (hex)		Siemens AG, PG IE R&D
300000-3FFFFF     (base 16)		Siemens AG, PG IE R&D
				Siemensalle 84
				Karlsruhe    76187
				DE

38-B8-EB   (hex)		MATRIXSTREAM TECHNOLOGIES, INC.
600000-6FFFFF     (base 16)		MATRIXSTREAM TECHNOLOGIES, INC.
				303 Twin Dolphins Drive 6th Floor Redwood Shores, california,USA 94065 
				california     94065 
				AM

38-B8-EB   (hex)		barox Kommunikation GmbH
200000-2FFFFF     (base 16)		barox Kommunikation GmbH
				Marie-Curie-Strasse 8
				Lörrach    DE-79539
				DE

1C-88-79   (hex)		gekartel AG
B00000-BFFFFF     (base 16)		gekartel AG
				Julius-Otto-Straße 7
				Dresden    01219
				DE

1C-88-79   (hex)		Newps co.,ltd
000000-0FFFFF     (base 16)		Newps co.,ltd
				33, Hoguk-ro
				Daegu  Korea  41502
				KR

1C-87-74   (hex)		Quest Integrity
E00000-EFFFFF     (base 16)		Quest Integrity
				19823 58TH PL S, STE 100
				Kent  WA  98032
				US

1C-88-79   (hex)		ITW-FEG
A00000-AFFFFF     (base 16)		ITW-FEG
				155 Harlem Avenue
				Glenview  IL  60025
				US

1C-87-76   (hex)		Artis GmbH
E00000-EFFFFF     (base 16)		Artis GmbH
				Buchenring 40
				Egestorf    21272
				DE

1C-87-79   (hex)		ASSYSTEM France
E00000-EFFFFF     (base 16)		ASSYSTEM France
				13 rue Marie Louise Dissard
				TOULOUSE    31024
				FR

1C-87-74   (hex)		Nichigaku
200000-2FFFFF     (base 16)		Nichigaku
				Oimachi 1-49-15
				Shinagawa  Tokyo  1400014
				JP

1C-87-74   (hex)		Philips Personal Health Solutions
000000-0FFFFF     (base 16)		Philips Personal Health Solutions
				High Tech Campus, HTC37 floor 0
				Eindhoven    5656 AE
				NL

1C-87-76   (hex)		Hekatron Vertriebs GmbH
B00000-BFFFFF     (base 16)		Hekatron Vertriebs GmbH
				Brühlmatten 9
				Sulzburg    79295
				DE

1C-87-76   (hex)		RDP.RU
400000-4FFFFF     (base 16)		RDP.RU
				3 Davydkovskaya street
				Moscow    121352
				RU

1C-87-79   (hex)		TASC Systems Inc.
700000-7FFFFF     (base 16)		TASC Systems Inc.
				9415 - 202 Street
				Langley  BRITISH COLUMBIA  V1M4B5
				CA

1C-87-79   (hex)		SMARTMOVT TECHNOLOGY Co.， LTD
200000-2FFFFF     (base 16)		SMARTMOVT TECHNOLOGY Co.， LTD
				Room204-210, F3 building, F518 Idea Land, Baoyuan road, Xixiang Ave, Bao’an District
				Shenzhen  Guangdong  518100 
				CN

1C-87-79   (hex)		Beijing Geedeen Technology Co., Ltd
B00000-BFFFFF     (base 16)		Beijing Geedeen Technology Co., Ltd
				Room 1701, Building A, Boya International Center, Lizezhongerlu, Chaoyang District
				Beijing  Beijing  100102
				CN

84-39-BE   (hex)		Guangzhou Heygears Technology Ltd
100000-1FFFFF     (base 16)		Guangzhou Heygears Technology Ltd
				Room 2301, #379 Zhongshan Road Central
				Guangzhou  Guangdong  510000
				CN

70-88-6B   (hex)		Church & Dwight Co., Inc.
600000-6FFFFF     (base 16)		Church & Dwight Co., Inc.
				500 Charles Ewing Blvd
				Ewing  NJ  08628
				US

40-A3-6B   (hex)		Onion Corporation
C00000-CFFFFF     (base 16)		Onion Corporation
				186 Denison Street
				Markham  Ontario  L3R 1B5
				CA

70-88-6B   (hex)		Bitfinder Inc
100000-1FFFFF     (base 16)		Bitfinder Inc
				20660 Stevens Creeks #345
				Cupertino  CA  95014
				US

40-A3-6B   (hex)		TW-TeamWare
100000-1FFFFF     (base 16)		TW-TeamWare
				Via Pindaro, 19
				Milano    20128
				IT

70-88-6B   (hex)		Cable Matters Inc.
800000-8FFFFF     (base 16)		Cable Matters Inc.
				153 Northboro Road, Suite 5
				Southborough  MA  01772
				US

70-88-6B   (hex)		Shenzhen Coolhear Information Technology Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen Coolhear Information Technology Co., Ltd.
				Room 502,Building A4, Kexing Science Park, Keyuan Road, Nanshan Distrct, Shenzhen, Guangdong,
				Shenzhen  Guangdong  518000
				CN

00-55-DA   (hex)		OOO DEKATRON
600000-6FFFFF     (base 16)		OOO DEKATRON
				Oseny boulevard 15 apart. 394
				Moscow  Moscow  121609
				RU

00-55-DA   (hex)		Quantum Communication Technology Co., Ltd.,Anhui
900000-9FFFFF     (base 16)		Quantum Communication Technology Co., Ltd.,Anhui
				D3 Innovation Industrial Park, No. 800 Wangjiang West Road, Hefei Hi-tech Industrial Development Zone, Hefei City, Anhui Province, China
				Hefei  Anhui  230088
				CN

CC-1B-E0   (hex)		Cassia Networks
E00000-EFFFFF     (base 16)		Cassia Networks
				Room B206 , ZhongGuanCun FaZhanDaSha
				Beijing  Beijing  100085
				CN

80-0A-80   (hex)		Golana Technology (Shenzhen) Co., Ltd.
000000-0FFFFF     (base 16)		Golana Technology (Shenzhen) Co., Ltd.
				4th Floor, Integration Building A1
				Shenzhen  Guangdong  518129
				CN

CC-1B-E0   (hex)		Matter Labs Pty Ltd
A00000-AFFFFF     (base 16)		Matter Labs Pty Ltd
				Suite 105
				South Yarra  Vic  3141
				AU

CC-1B-E0   (hex)		Beijing Daotongtianxia Co.Ltd.
100000-1FFFFF     (base 16)		Beijing Daotongtianxia Co.Ltd.
				Beijing, Haidian District, Taiyueyuan Building No.1, Taiyueshangwu Center Flo.5
				Beijing  Beijing  100088
				CN

A0-3E-6B   (hex)		Shenzhen Nufilo Inc.
400000-4FFFFF     (base 16)		Shenzhen Nufilo Inc.
				Tianliao Building F3,(New Materials Industrial Park),Xueyuan Road,Nanshan District,Shenzhen City,P.R.China
				Shenzhen  Guangdong  518055
				CN

C8-8E-D1   (hex)		Ube, Inc. (dba Plum)
700000-7FFFFF     (base 16)		Ube, Inc. (dba Plum)
				9800 N. Lamar Blvd., STE 310
				Austin  TX  78753-4160
				US

C8-8E-D1   (hex)		Shanghai Bwave Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Shanghai Bwave Technology Co.,Ltd
				6F,Building12,399 Keyuan Road, Zhangjiang Hi-Tech Park,shanghai,china
				Shanghai  Shanghai  201203
				CN

A0-3E-6B   (hex)		KoCoS Messtechnik AG
B00000-BFFFFF     (base 16)		KoCoS Messtechnik AG
				Südring 42
				Korbach  Hessen  34497
				DE

C8-8E-D1   (hex)		PHOENIX ENGINEERING CORP.
D00000-DFFFFF     (base 16)		PHOENIX ENGINEERING CORP.
				466-3 Fujikubo
				Irumagun  Saitama  354-0041
				JP

A0-3E-6B   (hex)		s&t embedded GmbH
000000-0FFFFF     (base 16)		s&t embedded GmbH
				Breslauer Str. 3
				Eching  Bayern  85386
				DE

1C-21-D1   (hex)		LG CNS
A00000-AFFFFF     (base 16)		LG CNS
				21F, FKI Tower, 24, Yeoui-daero, Yeongdeungpo-gu
				Seoul    150-881
				KR

1C-21-D1   (hex)		Global Design Solutions Ltd
B00000-BFFFFF     (base 16)		Global Design Solutions Ltd
				Unit 13
				Bristol  England  BS44ED
				GB

1C-21-D1   (hex)		Wuhan TieChi Detection Technology Co., Ltd.
600000-6FFFFF     (base 16)		Wuhan TieChi Detection Technology Co., Ltd.
				Hongshan District Luo Yu RoadBainaohui room 1513
				Wuhan  Hubei  430000
				CN

1C-21-D1   (hex)		Toyo System CO.,LTD.
000000-0FFFFF     (base 16)		Toyo System CO.,LTD.
				106-1,Zenita,Joban-Nishigo,
				Iwaki,  Fukushima  972-8316
				JP

1C-21-D1   (hex)		Varaani Works Oy
200000-2FFFFF     (base 16)		Varaani Works Oy
				Takojankatu 1c B 16
				Tampere  Pirkanmaa  33540
				FI

DC-44-27   (hex)		Rohde&Schwarz Topex SA
D00000-DFFFFF     (base 16)		Rohde&Schwarz Topex SA
				71th-73th Nicolae Caramfil street, 2nd floor, 1th district
				Bucuresti  Romania  014142
				RO

1C-21-D1   (hex)		Liscotech System Co., Ltd.
D00000-DFFFFF     (base 16)		Liscotech System Co., Ltd.
				4F. No. 342 Sec.4 Chenggong Rd. Neihu Dist.
				Taipei  TW  11458
				TW

1C-21-D1   (hex)		Soundtrack Your Brand Sweden AB
700000-7FFFFF     (base 16)		Soundtrack Your Brand Sweden AB
				Birger Jarlsgatan 43
				Stockholm    11145
				SE

C8-8E-D1   (hex)		Fibergate.Inc
500000-5FFFFF     (base 16)		Fibergate.Inc
				KDX Shibadaimon.Bld 2F Shibadaimon Minato-ku Tokyo 105-0012 Japan
				Tokyo  Minato-ku  105-0012
				JP

DC-44-27   (hex)		VerifEye Technologies
E00000-EFFFFF     (base 16)		VerifEye Technologies
				2-151 Whitehall Dr.
				Markham  ON  L3R9T1
				CA

C8-8E-D1   (hex)		Linx Technologies
300000-3FFFFF     (base 16)		Linx Technologies
				159 Ort Lane
				Merlin  OR  97532
				US

C8-8E-D1   (hex)		Comlab AG
400000-4FFFFF     (base 16)		Comlab AG
				Ey 13
				Ittigen  BE  3076
				CH

B0-C5-CA   (hex)		TEM Mobile Limited
A00000-AFFFFF     (base 16)		TEM Mobile Limited
				RM1703, North Block, Cangsong Building, Tairan 6 road, Futian District, Shenzhen.
				Shenzhen  Guangdong  518000
				CN

B0-C5-CA   (hex)		RISECOMM  (HK) TECHNOLOGY CO. LIMITED
B00000-BFFFFF     (base 16)		RISECOMM  (HK) TECHNOLOGY CO. LIMITED
				Skyworth Building C501, Hi-tech Industrial Park, Shenzhen, China
				shenzhan  guangdong  518057
				CN

B0-C5-CA   (hex)		LOWOTEC GmbH
200000-2FFFFF     (base 16)		LOWOTEC GmbH
				Marie-Curie-Str. 1
				Oldenburg  Niedersachsen  26129
				DE

78-C2-C0   (hex)		ShenZhen TuLing Robot CO.,LTD
500000-5FFFFF     (base 16)		ShenZhen TuLing Robot CO.,LTD
				BLK 9, No 28, Langshan Road, Northern District of High Tech. Industry Park, Nanshan Dist., SZ., PRC.
				ShenZhen  GuangDong  518000
				CN

B4-37-D1   (hex)		Axiomatic Technologies Corporation
A00000-AFFFFF     (base 16)		Axiomatic Technologies Corporation
				5915 Wallace St.
				Mississauga  ON  L4Z1Z8
				CA

74-F8-DB   (hex)		GHL Advanced Technology GmbH & Co. KG
100000-1FFFFF     (base 16)		GHL Advanced Technology GmbH & Co. KG
				Marie-Curie-Str. 20
				Kaiserslautern  RP  67661
				DE

54-9A-11   (hex)		Hangzhou duotin Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Hangzhou duotin Technology Co., Ltd.
				Haichuang Garden of Hangzhou city Yuhang District 4 Building 407B
				hangzhou  Zhejiang  311100
				CN

88-5D-90   (hex)		Gigatech R&D Corp.
900000-9FFFFF     (base 16)		Gigatech R&D Corp.
				7F-5, 16 Jian 8th road, Zhonghe Dist.
				New Taipei City  Taiwan  23511
				TW

88-5D-90   (hex)		ShenZhen Yuyangsheng technology company LTD
100000-1FFFFF     (base 16)		ShenZhen Yuyangsheng technology company LTD
				Yinfeng industrial park Jiu wei community
				shenzhen  guangdong  518000
				CN

88-5D-90   (hex)		Hi-Profile Achievement (M) Sdn Bhd
600000-6FFFFF     (base 16)		Hi-Profile Achievement (M) Sdn Bhd
				42A, Lorong Teras Jaya 2, Kawasan Perniagaan Teras Jaya
				Butterworth  Pulau Pinang  13400
				MY

54-9A-11   (hex)		VendNovation LLC
A00000-AFFFFF     (base 16)		VendNovation LLC
				13400 NE 20th Street
				Bellevue  WA  98005
				US

80-7B-85   (hex)		Shiroshita Industrial Co., Ltd.
000000-0FFFFF     (base 16)		Shiroshita Industrial Co., Ltd.
				1-1-58, Tokiiri
				Ueda-shi  Nagano  386-0015
				JP

80-7B-85   (hex)		Phoenix Co.,Ltd.
200000-2FFFFF     (base 16)		Phoenix Co.,Ltd.
				Perl Iidabashi Bldg.,
				Chiyoda-ku  Tokyo  102-0072
				JP

64-FB-81   (hex)		Sichuan Haige Actec Communication Technology Co.,Ltd.
B00000-BFFFFF     (base 16)		Sichuan Haige Actec Communication Technology Co.,Ltd.
				8 Mintai Road, Youxian District, Mianyang City, Sichuan
				Mianyang City  Sichuan  621022
				CN

80-7B-85   (hex)		IDair, LLC
800000-8FFFFF     (base 16)		IDair, LLC
				6767 Old Madison Pike
				Huntsville  AL  35806
				US

80-E4-DA   (hex)		Neutronics
A00000-AFFFFF     (base 16)		Neutronics
				456 Creamery Way
				Exton  Pennsylvania  19341
				US

64-FB-81   (hex)		Narrative AB
100000-1FFFFF     (base 16)		Narrative AB
				Agatan 55A
				Linkoping  -  58222
				SE

1C-CA-E3   (hex)		Insigma Inc
200000-2FFFFF     (base 16)		Insigma Inc
				43490, Yukon Drive, Suite 102
				Ashburn  VA  20147
				US

80-E4-DA   (hex)		Akenori PTE LTD
E00000-EFFFFF     (base 16)		Akenori PTE LTD
				176 JOO CHIAT ROAD #02-02
				    427447
				SG

1C-CA-E3   (hex)		Dream Visions Co., LTD
B00000-BFFFFF     (base 16)		Dream Visions Co., LTD
				90 Chongpa_Ro YoungSan-Gu
				Seoul  Seoul  140-742
				KR

1C-CA-E3   (hex)		Gahdeung Elecom
C00000-CFFFFF     (base 16)		Gahdeung Elecom
				203, Rojinmedical, 717, Lee-Dong, Sanrok-Gu
				ANSAN  Kyeonggi-Do  ASI|KR|KS009|ANSAN
				KR

1C-CA-E3   (hex)		TOKAI RIKA CO., LTD.
600000-6FFFFF     (base 16)		TOKAI RIKA CO., LTD.
				3-260
				Niwa-gun, Oguchi-cho  Aichi  480-0195
				JP

90-C6-82   (hex)		Shenzhen Photon Broadband Technology CO., LTD
100000-1FFFFF     (base 16)		Shenzhen Photon Broadband Technology CO., LTD
				8/F,C Bldg, Funing Hi-Tech Industrial Park, No.71 Fuyong Xintian Road,Baoan District Shenzhen,China
				Shenzhen  Guangdong  518103
				CN

90-C6-82   (hex)		ekey biometric systems gmbh
200000-2FFFFF     (base 16)		ekey biometric systems gmbh
				Lunzerstrsasse 89
				Linz  Upper Austria  4020
				AT

90-C6-82   (hex)		ACT
900000-9FFFFF     (base 16)		ACT
				Unit C1, South City Business Center
				Dublin    
				IE

2C-D1-41   (hex)		AOptix Technologies, Inc
300000-3FFFFF     (base 16)		AOptix Technologies, Inc
				675 Campbell Technology Pkwy
				Campbell  CA  95008
				US

2C-D1-41   (hex)		iCIRROUND Inc
000000-0FFFFF     (base 16)		iCIRROUND Inc
				7F,No.,79, Chou-Tze St.,
				Taipei  Taiwan  114
				TW

90-C6-82   (hex)		Beijing Acorn Networks Corporation
A00000-AFFFFF     (base 16)		Beijing Acorn Networks Corporation
				1A-601，Wang Jing Street, Chao Yang Qu, Beijing, China
				Beijing  Beijing  100102
				CN

2C-6A-6F   (hex)		Schneider Electric Korea
B00000-BFFFFF     (base 16)		Schneider Electric Korea
				14F Kbiz DMC tower,
				  Seoul  121-904
				KR

2C-D1-41   (hex)		Minno LLC
800000-8FFFFF     (base 16)		Minno LLC
				421 North Milpas Street
				Santa Barbara  CA  93103
				US

A0-BB-3E   (hex)		COMSYS Communications Systems Service GmbH
400000-4FFFFF     (base 16)		COMSYS Communications Systems Service GmbH
				TecCenter
				Bad Salzdetfurth  Niedersachsen  31162
				DE

98-02-D8   (hex)		Fritz Kuebler GmbH
600000-6FFFFF     (base 16)		Fritz Kuebler GmbH
				Schubertstrasse 47
				Villingen-Schwenningen  Baden-Wuerttemberg  78054
				DE

98-02-D8   (hex)		Grammer EiA Electronics nv
300000-3FFFFF     (base 16)		Grammer EiA Electronics nv
				Vluchtenburgstraat 3B
				Aartselaar  Antwerp  2630
				BE

A0-BB-3E   (hex)		Messtechnik Sachs GmbH
E00000-EFFFFF     (base 16)		Messtechnik Sachs GmbH
				Siechenfeldstr. 30/1
				Schorndorf  Germany  73614
				DE

98-02-D8   (hex)		SHENZHEN ATEKO PHOTOELECTRICITY CO LTD
100000-1FFFFF     (base 16)		SHENZHEN ATEKO PHOTOELECTRICITY CO LTD
				 4-5F, E1 Building, TCL International E City, No.1001 Zhongshanyuan Road, Nanshan District
				Shenzhen,  Guangdong  518052
				CN

F8-02-78   (hex)		Lit Technologies
E00000-EFFFFF     (base 16)		Lit Technologies
				2011 Stampede Dr
				Farmington  Utah  84025
				US

2C-26-5F   (hex)		XIAMEN VORLINK IOT TECHNOLOGY CO.,LTD.
000000-0FFFFF     (base 16)		XIAMEN VORLINK IOT TECHNOLOGY CO.,LTD.
				No.306 of Chengye Bldg., Xiamen Pioneering Park for Overseas Chinese Scholars
				xiamen  fujian  361000
				CN

28-FD-80   (hex)		T-Radio AS
E00000-EFFFFF     (base 16)		T-Radio AS
				Stensarmen 3A
				Tønsberg    3112
				NO

2C-26-5F   (hex)		Appostar Technology Co. Ltd
600000-6FFFFF     (base 16)		Appostar Technology Co. Ltd
				13F., No.213, Sec. 3, Beixin Rd., Xindian Dist., New Taipei City 231, Taiwan (R.O.C.)
				Xindian Dist  New Taipei City  231
				TW

2C-26-5F   (hex)		shenzhen Clever Electronic Co., Ltd.
300000-3FFFFF     (base 16)		shenzhen Clever Electronic Co., Ltd.
				Building 8, Baiwang Creative Park(UTCP),Nanshan District,Shenzhen,China
				Shenzhen  GuangDong  518055
				CN

28-FD-80   (hex)		NUUO, Inc.
300000-3FFFFF     (base 16)		NUUO, Inc.
				B1, No.207-1, Sec. 3, Beixin Rd.
				New Taipei City  Xindian Dist.  231
				TW

0C-EF-AF   (hex)		PREMIUM SA
500000-5FFFFF     (base 16)		PREMIUM SA
				C/ Dolors Aleu 19  2º 2º
				Hospitalet del Llobregat  Barcelona  08908
				ES

F8-02-78   (hex)		Technology Research, LLC
C00000-CFFFFF     (base 16)		Technology Research, LLC
				4525 140th Ave North
				Clearwater  FL  33762
				US

0C-EF-AF   (hex)		BSX Athletics
800000-8FFFFF     (base 16)		BSX Athletics
				2500 E T C Jester Blvd.
				Houston  TX  77008
				US

F8-02-78   (hex)		3Shape Holding A/S
300000-3FFFFF     (base 16)		3Shape Holding A/S
				Holmens Kanal 7,2
				Copenhagen K.  Copenhagen  1060
				DK

F8-02-78   (hex)		Digatron Power Electronics GmbH
000000-0FFFFF     (base 16)		Digatron Power Electronics GmbH
				Tempelhofer Str. 12-14
				Aachen  NRW  52068
				DE

F8-02-78   (hex)		Electric Objects
500000-5FFFFF     (base 16)		Electric Objects
				356 Bowery
				New York  NY  10021
				US

A4-4F-29   (hex)		Neotech Systems Pvt. Ltd.
E00000-EFFFFF     (base 16)		Neotech Systems Pvt. Ltd.
				B-25, 2nd floor
				New Delhi  Delhi  110049
				IN

A4-4F-29   (hex)		HALLIBURTON
D00000-DFFFFF     (base 16)		HALLIBURTON
				445 WOODLINE DR
				SPRING  TX  77386
				US

3C-39-E7   (hex)		iiM AG
A00000-AFFFFF     (base 16)		iiM AG
				Neuer Friedberg 5
				Suhl  Thuringia  98527
				DE

3C-39-E7   (hex)		Zone Controls AB
900000-9FFFFF     (base 16)		Zone Controls AB
				Verkstadsvägen 6
				Västerhaninge  Stockholms län  137 37
				SE

3C-39-E7   (hex)		Sensor to Image GmbH
700000-7FFFFF     (base 16)		Sensor to Image GmbH
				Lechtorstrasse 20
				Schongau  Bavaria  86956
				DE

0C-EF-AF   (hex)		LUMEL S.A.
200000-2FFFFF     (base 16)		LUMEL S.A.
				Ul.Slubicka 1
				Zielona Gora    65-127
				PL

10-07-23   (hex)		Ion Professional Solutions
800000-8FFFFF     (base 16)		Ion Professional Solutions
				4514 Flower Bridge Ct
				Humble  Texas  77396
				US

10-07-23   (hex)		First Chair Acoustics Co., Ltd.
E00000-EFFFFF     (base 16)		First Chair Acoustics Co., Ltd.
				No. 53, Lane 17, Yuhe Street
				Taoyuan City, Taoyuan County    33057
				TW

10-07-23   (hex)		Fujian Quanzhou Dong Ang Electronics Co., Ltd.
B00000-BFFFFF     (base 16)		Fujian Quanzhou Dong Ang Electronics Co., Ltd.
				5th floor of Hengtaixing mansion, Yingbin Road
				Quanzhou  Fujian  362000
				CN

10-07-23   (hex)		nanoTech Co., Ltd.
700000-7FFFFF     (base 16)		nanoTech Co., Ltd.
				4-2-17 Chuorinka
				Yamato  Kanagawa  242-0007
				JP

D0-22-12   (hex)		UAB &quot;SALDA&quot;
900000-9FFFFF     (base 16)		UAB &quot;SALDA&quot;
				Ragaines 100
				Šiauliai  Europe  LT-78109
				LT

D0-22-12   (hex)		Schleifenbauer Holding BV
B00000-BFFFFF     (base 16)		Schleifenbauer Holding BV
				Rietwaard 15
				Hertogenbosch    5236WC 
				NL

D0-22-12   (hex)		Shanghai Routech Co., Ltd
500000-5FFFFF     (base 16)		Shanghai Routech Co., Ltd
				R.709-(2), B Zone, No.668 Eastern Beijing Rd. Shanghai P.R.C
				Shanghai  Shanghai  200001
				CN

D0-22-12   (hex)		Cliptech Industria e Comercio Ltda
700000-7FFFFF     (base 16)		Cliptech Industria e Comercio Ltda
				ROD VICE PREF HERMENEGILDO TONOLI, 2285
				ITUPEVA  SAO PAULO  13295000
				BR

D0-22-12   (hex)		u::Lux GmbH
E00000-EFFFFF     (base 16)		u::Lux GmbH
				Rechtes Salzachufer 42
				Bergheim  Salzburg  5101
				AT

74-E1-4A   (hex)		Knog Pty Ltd
D00000-DFFFFF     (base 16)		Knog Pty Ltd
				453 Church St
				Richmond  VIC  3128
				AU

74-E1-4A   (hex)		Loctek Visual Technology Corp.
B00000-BFFFFF     (base 16)		Loctek Visual Technology Corp.
				Floor 20 Aux Building No.757 Rili Middle Road Yinzhou District Ningbo China
				Ningbo  zhejiang  315199
				CN

E8-18-63   (hex)		Acopian Technical Company
E00000-EFFFFF     (base 16)		Acopian Technical Company
				131 Loomis Street
				Easton  PA  18045
				US

B8-D8-12   (hex)		Docobo Limited
B00000-BFFFFF     (base 16)		Docobo Limited
				The Old Granary, 21 High Street
				Leatherhead  Surrey  KT23 4AA
				GB

E4-95-6E   (hex)		iConservo Inc
B00000-BFFFFF     (base 16)		iConservo Inc
				35 Tesla
				Irvine  CA  92618
				

E4-95-6E   (hex)		Red Point Positioning, Corp.
A00000-AFFFFF     (base 16)		Red Point Positioning, Corp.
				20 Webster Street, Suite 411
				Brookline  MASSACHUSETTS  02446
				US

74-E1-4A   (hex)		UTU Oy
500000-5FFFFF     (base 16)		UTU Oy
				Ahjontie 1
				Ulvila  Finland  28400
				FI

E4-95-6E   (hex)		ELAN SYSTEMS
500000-5FFFFF     (base 16)		ELAN SYSTEMS
				10 IHASZ STR
				BUDAPEST    1105
				HU

E4-95-6E   (hex)		Shenzhen Arronna Telecom Co.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen Arronna Telecom Co.,Ltd
				4F, Block 1, No 17-2, Pingxi South Rd
				Shenzhen  Guangdong  518117
				CN

B0-1F-81   (hex)		CIDE Interactive
900000-9FFFFF     (base 16)		CIDE Interactive
				Viladecans Business Pk, Edificio Brasil
				Viladecans  Barcelona  08840
				ES

58-FC-DB   (hex)		Timex Group USA Inc
600000-6FFFFF     (base 16)		Timex Group USA Inc
				555 Christian Rd
				Middlebury  CT  06762
				US

BC-66-41   (hex)		ARGUS-SPECTRUM
400000-4FFFFF     (base 16)		ARGUS-SPECTRUM
				Serdobolskaya str.,65
				St-Petersburg    197342
				RU

B0-1F-81   (hex)		Steffens Systems GmbH
A00000-AFFFFF     (base 16)		Steffens Systems GmbH
				Mathias-Brüggenstr. 83
				Cologne  NRW  50829
				DE

F4-0E-11   (hex)		Zeepro Inc.
800000-8FFFFF     (base 16)		Zeepro Inc.
				151 10th Street
				San Francisco  California  94103
				US

F4-0E-11   (hex)		Alpha Design Technologies Pvt Ltd
600000-6FFFFF     (base 16)		Alpha Design Technologies Pvt Ltd
				#9, Service Road, HAL II Stage
				Bangalore  Karnataka  560008
				IN

14-1F-BA   (hex)		AJIS(DALIAN)co.,LTD
D00000-DFFFFF     (base 16)		AJIS(DALIAN)co.,LTD
				Room 202B
				Dalian  Liaoning  116023
				CN

F4-0E-11   (hex)		BRADAR INDUSTRIA SA
B00000-BFFFFF     (base 16)		BRADAR INDUSTRIA SA
				AVENIDA SHISHIMA HIFUMI,2911
				SÃO JOSE DOS CAMPOS  SÃO PAULO  12244-000
				BR

BC-34-00   (hex)		MATICA TECHNOLOGIES AG
800000-8FFFFF     (base 16)		MATICA TECHNOLOGIES AG
				52 TECKSTRASSE
				ESSLINGEN AM NECKAR  BADEN WUERTTENBERG  73734
				DE

BC-34-00   (hex)		Shenzhen PHilorise Technical Limited
900000-9FFFFF     (base 16)		Shenzhen PHilorise Technical Limited
				Floor 4, Building 2, TingWeiGongYeQu,
				ShenZhen  GuangDong  518010
				CN

14-1F-BA   (hex)		Thales Communications & Security SAS
600000-6FFFFF     (base 16)		Thales Communications & Security SAS
				BP 57
				Bretigny-sur-Orge CEDEX  France  F 91229
				FR

BC-34-00   (hex)		Hangzhou Linker Digital Technology Co., Ltd
D00000-DFFFFF     (base 16)		Hangzhou Linker Digital Technology Co., Ltd
				4-5F, C Building, Jinrun Tech-Garden, 399# Qiuyi Road, Binjiang District
				Hangzhou  ZheJiang  310052
				CN

BC-34-00   (hex)		LLD Technology Ltd.
E00000-EFFFFF     (base 16)		LLD Technology Ltd.
				4F., No. 220, Sec. 1, Zhongshan Rd.,
				New Taipei City,  Taiwan  234
				TW

BC-34-00   (hex)		FARO TECHNOLOGIES, INC.
B00000-BFFFFF     (base 16)		FARO TECHNOLOGIES, INC.
				125 Technology Park
				Lake Mary  FL  32746
				US

7C-70-BC   (hex)		mk-messtechnik GmbH
D00000-DFFFFF     (base 16)		mk-messtechnik GmbH
				Zeppelinstr. 1
				Notzingen  D  73274
				DE

7C-70-BC   (hex)		Bidgely
600000-6FFFFF     (base 16)		Bidgely
				298  S Sunnyvale Ave
				Sunnyvale  CA  94086
				US

14-1F-BA   (hex)		Inttelix Brasil Tecnologia e Sistemas Ltda
500000-5FFFFF     (base 16)		Inttelix Brasil Tecnologia e Sistemas Ltda
				 Rua Desembargador Jorge Fontana, 112B, Belvedere
				Belo Horizonte  Minas Gerais  30320-670
				BR

14-1F-BA   (hex)		Shenzhen Mining Technology Co.,Ltd.
000000-0FFFFF     (base 16)		Shenzhen Mining Technology Co.,Ltd.
				2017#Baoan Internet Industry Base,Langman Gangwan
				Shenzhen  Guangdong  518000
				CN

BC-34-00   (hex)		LifeSmart
200000-2FFFFF     (base 16)		LifeSmart
				1911, Huarong Times Plaza
				Hangzhou  Zhejiang  310052
				CN

D0-76-50   (hex)		Electro-Motive Diesel
C00000-CFFFFF     (base 16)		Electro-Motive Diesel
				9301 W. 55th Street
				La Grange  IL  60525
				US

BC-34-00   (hex)		NDSL, Inc.
500000-5FFFFF     (base 16)		NDSL, Inc.
				4112 Blue Ridge Road
				Raleigh  North Carolina  27612
				US

A4-3B-FA   (hex)		BOI Solutions
500000-5FFFFF     (base 16)		BOI Solutions
				955 Mound Rd
				Miamisburg  Ohio  45342
				US

D0-76-50   (hex)		Happo Solutions Oy
200000-2FFFFF     (base 16)		Happo Solutions Oy
				Graanintie 5
				MIKKELI    50190
				FI

74-19-F8   (hex)		Volacomm Co., Ltd
E00000-EFFFFF     (base 16)		Volacomm Co., Ltd
				15F-6., No.7, Sec.3, New Taipei Blvd., Xinzhuang Dist., New Taipei City 242., Taiwan (R.O.C)
				Xinzhuang Dist.  New Taipei City  242
				TW

74-19-F8   (hex)		Baudisch Electronic GmbH
600000-6FFFFF     (base 16)		Baudisch Electronic GmbH
				Im Gewerbegebiet 7-9
				Wäschenbeuren  Baden-Württemberg  73116
				DE

D0-76-50   (hex)		TAPKO Technologies GmbH
300000-3FFFFF     (base 16)		TAPKO Technologies GmbH
				Im Gewerbepark A15
				Regensburg  Bayern  93059
				DE

74-19-F8   (hex)		Marmitek
000000-0FFFFF     (base 16)		Marmitek
				Postbus 4257
				Eindhoven  NB  5604 EG
				NL

40-11-75   (hex)		ShenZhen LanShuo Communication Equipment CO.,LTD.
600000-6FFFFF     (base 16)		ShenZhen LanShuo Communication Equipment CO.,LTD.
				NO.12,YUMIN ROAD,SHAJING TOWN,BAO’AN DISTRICT
				SHENZHEN    518104
				CN

10-DC-B6   (hex)		BBPOS International Limited
C00000-CFFFFF     (base 16)		BBPOS International Limited
				Suite 1602, Tower 2, Nina Tower, 8 Yeung Uk Road, Tsuen Wan, NT
				Hong Kong  China  00000
				HK

10-DC-B6   (hex)		Eyeball Fintech Company
B00000-BFFFFF     (base 16)		Eyeball Fintech Company
				Rm. 545, 5F., No. 19-11, Sanchong Rd., Nangang Dist.
				Taipei City  Taiwan  11501
				TW

10-DC-B6   (hex)		HANACNS 
300000-3FFFFF     (base 16)		HANACNS 
				42-11, Taejanggongdan-gil, Wonju-si
				Gangwon-do    26311
				KR

10-DC-B6   (hex)		LeoLabs
D00000-DFFFFF     (base 16)		LeoLabs
				Jankowicka 51
				Rybnik    44-218
				PL

10-DC-B6   (hex)		Fuzhou Rockchip Electronics Co.,Ltd
900000-9FFFFF     (base 16)		Fuzhou Rockchip Electronics Co.,Ltd
				No. 18 Building, A District, No.89,software Boulevard Fuzhou,Fujian,PRC
				Fuzhou  FuJian  350003
				CN

10-DC-B6   (hex)		ABB Switzerland Ltd.
100000-1FFFFF     (base 16)		ABB Switzerland Ltd.
				Fabrikstrasse 3
				Lenzburg    5600
				CH

10-DC-B6   (hex)		Milesight Taiwan
500000-5FFFFF     (base 16)		Milesight Taiwan
				10F., No. 87, Sec. 4, Chongxin Rd
				Sanchong Dist  New Taipei City  24161
				TW

54-A4-93   (hex)		BJ COTYTECH TECHNOLOGY CO.,LTD
C00000-CFFFFF     (base 16)		BJ COTYTECH TECHNOLOGY CO.,LTD
				Rm2302,Block B,Haojing Building,Zhichun Road,Haidian District
				BeiJing  BeiJing  100086
				CN

54-A4-93   (hex)		Hannto Technology Co., Ltd
600000-6FFFFF     (base 16)		Hannto Technology Co., Ltd
				Rm 704,No.1,Lane 88,Shengrong Road, Free Trade Pilot Area,
				Shanghai  Shanghai  200120
				CN

54-A4-93   (hex)		genua GmbH
200000-2FFFFF     (base 16)		genua GmbH
				Domagkstr. 7
				Kirchheim    85551
				DE

04-D1-6E   (hex)		Metra Electronics
A00000-AFFFFF     (base 16)		Metra Electronics
				460 Walker Street
				Holly Hill  FL  32117
				US

04-D1-6E   (hex)		ETL Elektrotechnik Lauter GmbH
600000-6FFFFF     (base 16)		ETL Elektrotechnik Lauter GmbH
				Konrad-Zuse-Str. 2
				Mauerstetten  Bavaria  87665
				DE

04-D1-6E   (hex)		 Beijing Huaxia Qixin Technology Co., Ltd.
300000-3FFFFF     (base 16)		 Beijing Huaxia Qixin Technology Co., Ltd.
				 7th Floor, Building 1, No. 18, Yangfangdian Road, Haidian District, Beijing 705 
				Beijing  Beijing  100038
				CN

04-D1-6E   (hex)		National Radio & Telecommunication Corporation - NRTC
B00000-BFFFFF     (base 16)		National Radio & Telecommunication Corporation - NRTC
				House 420, Street 13, Chaklala Scheme 3
				Rawalpindi  Islamabad  46000
				PK

04-D1-6E   (hex)		INTRIPLE, a.s.
000000-0FFFFF     (base 16)		INTRIPLE, a.s.
				K Zelenci 2957/5
				Praha 9 - Horni Pocernice    193 00
				CZ

44-03-77   (hex)		SHENZHEN UT-KING TECHNOLOGY CO.,LTD
900000-9FFFFF     (base 16)		SHENZHEN UT-KING TECHNOLOGY CO.,LTD
				504, Building B ,Guangming Industrial Park, Zhonghua  Road, Minzhi, Longhua District
				SHENZHEN  GUANGDONG  518131
				CN

44-03-77   (hex)		Gemmy Electronics (Shenzhen) Co, Ltd
800000-8FFFFF     (base 16)		Gemmy Electronics (Shenzhen) Co, Ltd
				Datianyang Ind. Estate, Dongfang Road, Dangfang Road, Songgang Town, Bao'an District
				Shenzhen  Guangdong  518105
				CN

44-03-77   (hex)		BIG Climatic Manufacture, Co. LTD, Zhongshan Branch
C00000-CFFFFF     (base 16)		BIG Climatic Manufacture, Co. LTD, Zhongshan Branch
				Nantou Dadao, 20
				Zhongshan  Guangdong  528427
				CN

50-62-55   (hex)		Shenzhen Sinway South Technology Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen Sinway South Technology Co., Ltd
				No.7, Guantian Road, Guanlan Street, Longhua District
				Shenzhen  Guangdong  518110
				CN

50-62-55   (hex)		CHENGDU COVE TECHNOLOGY CO.,LTD
B00000-BFFFFF     (base 16)		CHENGDU COVE TECHNOLOGY CO.,LTD
				No.1-3, Floor 4, Building 2,No.1366 Middle Section of Tianfu Ave
				Chengdu   SICHUAN  610000
				CN

50-62-55   (hex)		XSLAB Inc.
400000-4FFFFF     (base 16)		XSLAB Inc.
				#1103, 11, DIGITAL-RO 33-GIL, GURO-GU
				SEOUL    08380
				KR

50-62-55   (hex)		ShenZhen ChuangMo Electronics Technology Co., Ltd
200000-2FFFFF     (base 16)		ShenZhen ChuangMo Electronics Technology Co., Ltd
				West Floor 4,building A,Bafangyuan high and new industrial zone,No.108 Zhoushi Rd.,Shiyan sub-district,Baoan, 
				Shenzhen  Guangdong  518108
				CN

64-31-39   (hex)		SHENZHEN EMEET INTELLIGENT TECHNOLOGY CO., LTD.
000000-0FFFFF     (base 16)		SHENZHEN EMEET INTELLIGENT TECHNOLOGY CO., LTD.
				Unit 2C,Building A6,Guangming Science Park,Guangming Road 3009
				Shenzhen  Guangdong  518000
				CN

64-31-39   (hex)		ZHEJIANG MOORGEN INTELLIGENT TECHNOLOGY CO.,LTD
D00000-DFFFFF     (base 16)		ZHEJIANG MOORGEN INTELLIGENT TECHNOLOGY CO.,LTD
				5 / F, Building A, qinghua pioneer park?No. 318 Tianhu Road, Camel Street, Zhenhai District
				Ningbo    315202
				CN

64-31-39   (hex)		ATG UV Technology
E00000-EFFFFF     (base 16)		ATG UV Technology
				Genesis House
				Wigan    WN5 8AA
				GB

C4-95-4D   (hex)		Marble Automation
500000-5FFFFF     (base 16)		Marble Automation
				Keteldiep 6
				Urk    8321 MH
				NL

00-69-67   (hex)		Shenzhen Xiao Bi En Culture Education Technology Co.,Ltd.
500000-5FFFFF     (base 16)		Shenzhen Xiao Bi En Culture Education Technology Co.,Ltd.
				4GH Unit,Block D,Central Avenue,Intersection of Xixiang Avenue and Baoyuan Road,Labor Community,Xixiang Street,Baoan District
				Shenzhen  China  518102
				CN

00-69-67   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

00-69-67   (hex)		Suzhou Radiant Lighting Technology Co.,Ltd
300000-3FFFFF     (base 16)		Suzhou Radiant Lighting Technology Co.,Ltd
				Jiatai Road West, Shuanglong Industrial Park,Fenghuang Town
				Zhangjiagang  Jiangsu  215600
				CN

A0-22-4E   (hex)		Zhuhai Cheer Technology Co., LTD.
500000-5FFFFF     (base 16)		Zhuhai Cheer Technology Co., LTD.
				No.8 Hongwan Road, Hongwan Industry Zone, Xiangzhou District
				Zhuhai  Guangdong  519060
				CN

A0-22-4E   (hex)		Digifocus Technology Inc.
D00000-DFFFFF     (base 16)		Digifocus Technology Inc.
				6F, No.89, Xinhu 1st Rd., Neihu Dist.
				Taipei City     11494
				TW

A0-22-4E   (hex)		Delta Tau Data Systems, Inc.
900000-9FFFFF     (base 16)		Delta Tau Data Systems, Inc.
				21314 Lassen St.
				Chatsworth  CA  91311
				US

A0-22-4E   (hex)		Closed Joint-Stock Company NORSI-TRANS
200000-2FFFFF     (base 16)		Closed Joint-Stock Company NORSI-TRANS
				B.Novodmitrovskaya Street, house 12, building 15
				Moscow    127015
				RU

A0-22-4E   (hex)		All Inspire Health Inc.
B00000-BFFFFF     (base 16)		All Inspire Health Inc.
				19 Morris Avenue, Building 128, Cumberland Gate
				Brooklyn  NY  11205
				US

20-0A-0D   (hex)		Welzek (Beijing) Technologies  Co, Ltd
900000-9FFFFF     (base 16)		Welzek (Beijing) Technologies  Co, Ltd
				No 201,Building 12, Chaolai Science Park, No.36 Chuangyuan RoadLaiguangying, Chaoyang Disctrict
				Beijing  Beijing  100012
				CN

20-0A-0D   (hex)		Virtium
400000-4FFFFF     (base 16)		Virtium
				30052 Tomas
				Racho Santa MArgarita  CA  92688
				US

20-0A-0D   (hex)		halstrup-walcher GmbH
000000-0FFFFF     (base 16)		halstrup-walcher GmbH
				Stegener Straße 10
				Kirchzarten    79199
				DE

40-2C-76   (hex)		gridX GmbH
C00000-CFFFFF     (base 16)		gridX GmbH
				Oppenhoffallee 143
				Aachen    52066
				DE

50-DE-19   (hex)		OCEANCCTV LTD
600000-6FFFFF     (base 16)		OCEANCCTV LTD
				4F., No. 1, Ln. 297, Xinyi Rd.,Banqiao Dist.,
				New Taipei City    220
				TW

40-2C-76   (hex)		LS Energy Solutions
E00000-EFFFFF     (base 16)		LS Energy Solutions
				9201 Forsyth Park Drive
				Charlotte  NC  28273
				US

50-DE-19   (hex)		IVATIV, INC
800000-8FFFFF     (base 16)		IVATIV, INC
				6141 RUNNING SPRINGS RD
				SAN JOSE  CA  95135
				US

3C-FA-D3   (hex)		Nox Medical
600000-6FFFFF     (base 16)		Nox Medical
				Katrinartun 2
				Reykjavik    105
				IS

B0-B3-53   (hex)		Hangzhou Hikrobot Technology Co., Ltd.
600000-6FFFFF     (base 16)		Hangzhou Hikrobot Technology Co., Ltd.
				Room 304, Unit B, Building 2, 399 Danfeng Road, Binjiang District, Hangzhou, Zhejiang
				Hangzhou    310052
				CN

B0-B3-53   (hex)		Sprocomm Technologies CO.,LTD.
100000-1FFFFF     (base 16)		Sprocomm Technologies CO.,LTD.
				5D F1.6 Block,Tianfa Building,Tianan Chegongmiao Industrial park,Futian Dist
				shenzhen  guangdong  518000
				CN

3C-FA-D3   (hex)		Mirico
E00000-EFFFFF     (base 16)		Mirico
				30 DongSan Rd 9th floor Mirico
				Ansan  Gyunggi  15434
				KR

B0-B3-53   (hex)		Innotas Elektronik GmbH
400000-4FFFFF     (base 16)		Innotas Elektronik GmbH
				Rathenaustr. 18a
				Zittau    D-02763
				DE

B0-B3-53   (hex)		VOXISCOM
800000-8FFFFF     (base 16)		VOXISCOM
				Rue Jules Ferry
				PORNIC    44210
				FR

90-E2-FC   (hex)		Power Engineering & Manufacturing, Inc.
A00000-AFFFFF     (base 16)		Power Engineering & Manufacturing, Inc.
				1463 94th Lane NE
				Blaine  MN  55449
				US

90-E2-FC   (hex)		Sindoh Techno Co., Ltd.
600000-6FFFFF     (base 16)		Sindoh Techno Co., Ltd.
				Sindoh Bldg., 6, Hyoryeong-ro 61-gil, Seocho-gu
				Seoul    06643
				KR

90-E2-FC   (hex)		Shenzhen Hisource Technology Development CO.,Ltd.
300000-3FFFFF     (base 16)		Shenzhen Hisource Technology Development CO.,Ltd.
				Dalang
				Shenzhen  Guangdong  518109
				CN

90-E2-FC   (hex)		TOTALONE TECHNOLOGY CO., LTD.
500000-5FFFFF     (base 16)		TOTALONE TECHNOLOGY CO., LTD.
				3F.-1, NO.18, LN. 48, XingShan RD.,
				Taipei  Neihu dist  11469
				TW

90-E2-FC   (hex)		Yite technology
100000-1FFFFF     (base 16)		Yite technology
				No. 56, Xiaobei Rd., North Dist
				tainan    70448 
				TW

90-E2-FC   (hex)		DevCom spol. s r.o.
E00000-EFFFFF     (base 16)		DevCom spol. s r.o.
				Božanovská 884
				Praha  Select a State  19300
				CZ

14-AE-85   (hex)		IO Industries Inc.
C00000-CFFFFF     (base 16)		IO Industries Inc.
				15940 Robin's Hill Rd
				London  Ontario  N5V 0A4
				CA

90-E2-FC   (hex)		Fair Winds Digital srl
700000-7FFFFF     (base 16)		Fair Winds Digital srl
				Via Italo Svevo 85
				Rome  Italy  00137
				IT

14-AE-85   (hex)		AZ-TECHNOLOGY SDN BHD
500000-5FFFFF     (base 16)		AZ-TECHNOLOGY SDN BHD
				A108 & A109 BLOCK A KELANA BUSINESS CENTRE NO: 97 JALAN SS7/2 KELANA JAYA
				PETALING JAYA  SELANGOR  47301
				MY

14-AE-85   (hex)		CENTERVUE SPA
400000-4FFFFF     (base 16)		CENTERVUE SPA
				VIA SAN MARCO 9/H
				PADOVA  PADOVA  35129
				IT

14-AE-85   (hex)		TMG TE GmbH
600000-6FFFFF     (base 16)		TMG TE GmbH
				Zur Gießerei 10
				Karlsruhe    776227
				DE

14-AE-85   (hex)		Sercomm Corporation.
E00000-EFFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

14-AE-85   (hex)		NTC SOFT
B00000-BFFFFF     (base 16)		NTC SOFT
				B-805, Gwangmyeong SK Techno park, 60, Haan-ro,
				Gwangmyeong-si  Gyeonggi-do  14322
				KR

94-CC-04   (hex)		Hangzhou Yongkong Technology Co., Ltd.
000000-0FFFFF     (base 16)		Hangzhou Yongkong Technology Co., Ltd.
				Room 503, Building 12, Lefu Zhihui Garden, 28 Xiangyuan Road, Gongshu Distric
				Hangzhou  Zhejiang  310000
				CN

64-62-66   (hex)		Jiangsu Aisida Electronic Co.,Ltd
C00000-CFFFFF     (base 16)		Jiangsu Aisida Electronic Co.,Ltd
				Aisida Industrial Park,Lanling Road,Danyang Development Zone
				DanYang  JiangSu  212300
				CN

94-CC-04   (hex)		Gowing Business And Contracting Wenzhou Co., LTD
700000-7FFFFF     (base 16)		Gowing Business And Contracting Wenzhou Co., LTD
				Room 101, No.4 Liming Industrial District, Lucheng, Wenzhou, China
				Wenzhou    325000
				CN

94-CC-04   (hex)		CircuitWerkes, Inc.
800000-8FFFFF     (base 16)		CircuitWerkes, Inc.
				2805 NW 6th St
				Gainesville  FL  32609
				US

14-AE-85   (hex)		IFLYTEK CO.,LTD.
300000-3FFFFF     (base 16)		IFLYTEK CO.,LTD.
				National Intelligent Speech High-tech Industrialization Base, No. 666, Wangjiang Road West,
				Hefei  An hui  230088
				CN

94-05-BB   (hex)		Shenzhen Baolijie Technology Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen Baolijie Technology Co., Ltd.
				D2,No.47,Shasan Road,Sha jing Street,Baoan District
				Shenzhen  Kowloon  518104
				CN

94-CC-04   (hex)		ProConnections, Inc.
400000-4FFFFF     (base 16)		ProConnections, Inc.
				30 Massachusetts, Ave, Suite 301
				North Andover  MA  01845
				US

94-05-BB   (hex)		Dongguan Kingtron Electronics Tech Co., Ltd
100000-1FFFFF     (base 16)		Dongguan Kingtron Electronics Tech Co., Ltd
				No.3 Fumin North Rd,Shu'an Industrial Park, Humen Town
				Dongguan  Guangdong China  523929
				CN

94-05-BB   (hex)		Sunthink S&T Development Co.,Ltd
D00000-DFFFFF     (base 16)		Sunthink S&T Development Co.,Ltd
				A3-f1, xinghezhong Technology Green Valley, No.14, luolei Industrial Avenue, Shiyan street, Bao'an District
				Shenzhen    518100
				CN

DC-44-27   (hex)		Tesla,Inc.
100000-1FFFFF     (base 16)		Tesla,Inc.
				3500 Deer Creek Road
				Palo Alto  CA  94304
				US

F4-90-CB   (hex)		ICE Gateway GmbH
200000-2FFFFF     (base 16)		ICE Gateway GmbH
				Am Studio 2
				Berlin  Berlin  12489
				DE

C0-9B-F4   (hex)		SHENZHEN WINS ELECTRONIC TECHNOLOGY CO., LTD
800000-8FFFFF     (base 16)		SHENZHEN WINS ELECTRONIC TECHNOLOGY CO., LTD
				Baoan Xixiang Xinbaoji Industry Park,Building A1-2
				Shenzhen  Guangdong  518026
				CN

F4-90-CB   (hex)		DELEM BV
100000-1FFFFF     (base 16)		DELEM BV
				LUCHTHAVEN WEG 42
				5657 EB EINDHOVEN    
				NL

C0-9B-F4   (hex)		Hitachi High-Tech Materials Corporation
200000-2FFFFF     (base 16)		Hitachi High-Tech Materials Corporation
				Toranomon Hills Business Tower, 1-17-1 Toranomon, Minato-ku
				Tokyo    105-6413
				JP

E8-B4-70   (hex)		UNICACCES GROUPE
E00000-EFFFFF     (base 16)		UNICACCES GROUPE
				24 Chemin des Vieilles Vignes
				La tour-d'aigues  Vaucluse  84240
				FR

E8-B4-70   (hex)		Digifocus Technology Inc.
B00000-BFFFFF     (base 16)		Digifocus Technology Inc.
				6F, No.89, Xinhu 1st Rd., Neihu Dist.
				Taipei City     11494
				TW

E8-B4-70   (hex)		Autocom Diagnostic Partner AB
100000-1FFFFF     (base 16)		Autocom Diagnostic Partner AB
				Grafitvägen 23B
				TROLLHÄTTAN    46138
				SE

94-FB-A7   (hex)		Silver-I Co.,LTD.
800000-8FFFFF     (base 16)		Silver-I Co.,LTD.
				2-14-4 Shinyokohama,kohoku-ku
				Yokohama  Kanagawa  222-0033
				JP

38-F7-CD   (hex)		NORDI TELEKOMMUNIKATSIOONI OÜ
400000-4FFFFF     (base 16)		NORDI TELEKOMMUNIKATSIOONI OÜ
				Valukoja 8
				Tallinn city  Estonian Republic  11415
				EE

38-F7-CD   (hex)		Shanghai qinzhuo Electronic Co., Ltd.
500000-5FFFFF     (base 16)		Shanghai qinzhuo Electronic Co., Ltd.
				No. W, floor 1, building 2, No. 258, Minfeng Road, Pudong New Area
				Shanghai  Shanghai  201209
				CN

38-F7-CD   (hex)		RFbeam Microwave GmbH
900000-9FFFFF     (base 16)		RFbeam Microwave GmbH
				Schuppisstrasse 7
				St. Gallen    9016
				CH

38-F7-CD   (hex)		Shenzhen MADIGI Electronic Technology Co., Ltd
C00000-CFFFFF     (base 16)		Shenzhen MADIGI Electronic Technology Co., Ltd
				Room 111,1A Floor,Kanghesheng Blgg,No.1.Chuangsheng Rd.Nanshan District
				Shenzhen  Guangdong  518000
				CN

70-69-79   (hex)		Faurecia Clarion Electronics (Dongguan) Co., Ltd
900000-9FFFFF     (base 16)		Faurecia Clarion Electronics (Dongguan) Co., Ltd
				South of Dongkeng Avenue, Dongkeng Town, Dongguan City, Guangdong
				DONGGUAN  GUANGDONG  523455
				CN

38-F7-CD   (hex)		BlastWave Inc.
800000-8FFFFF     (base 16)		BlastWave Inc.
				1987 Leghorn Street, Suite 100
				Moutain View  CA  94043
				US

70-69-79   (hex)		Intelitech SIA
700000-7FFFFF     (base 16)		Intelitech SIA
				2-22 Kruzes str.
				Riga  Other  LV-1046
				LV

70-69-79   (hex)		Beijing Security Union Information Technology Co.,Ltd
600000-6FFFFF     (base 16)		Beijing Security Union Information Technology Co.,Ltd
				Beijing Security Union Information Technology Co.,Ltd 
				Beijing  Beijing  100085
				CN

CC-C2-61   (hex)		Dspread Technology (Beijing) Inc.
D00000-DFFFFF     (base 16)		Dspread Technology (Beijing) Inc.
				Jingxin Building, 2045 Suite , Chaoyang District
				Beijing    100027
				CN

CC-C2-61   (hex)		Viper Design, LLC
500000-5FFFFF     (base 16)		Viper Design, LLC
				125 Glancy St.
				Goodlettsville  TN  37072
				US

CC-C2-61   (hex)		Ebiologic Technology Co., Ltd.
000000-0FFFFF     (base 16)		Ebiologic Technology Co., Ltd.
				9F., No.33, Ln. 3, Sec. 1, Zhongzheng E. Rd., Tamsui Dist., New Taipei City 251, Taiwan (R.O.C.)
				New Taipei City    251
				TW

CC-C2-61   (hex)		BYTERG LLC
900000-9FFFFF     (base 16)		BYTERG LLC
				1st Nagatinsky proezd 10 build.1
				Moscow  Moscow  115230
				RU

F0-D7-AF   (hex)		ADAM Audio GmbH
400000-4FFFFF     (base 16)		ADAM Audio GmbH
				Rudower Chaussee 50
				Berlin    12489
				DE

B0-B3-53   (hex)		AD HOC DEVELOPMENTS S.L
300000-3FFFFF     (base 16)		AD HOC DEVELOPMENTS S.L
				C/ Crisol 3, despacho 17
				Rivas-Vaciamadrid  Madrid  28522
				ES

F0-D7-AF   (hex)		Anord Mardix (USA) Inc.
600000-6FFFFF     (base 16)		Anord Mardix (USA) Inc.
				3930 Technology Court
				Sandston  VA  23150
				US

F0-D7-AF   (hex)		SHEN ZHEN MICHIP TECHNOLOGIES CO.,LTD.
800000-8FFFFF     (base 16)		SHEN ZHEN MICHIP TECHNOLOGIES CO.,LTD.
				Fuxingda Indestrial park.Floor4?Building4
				SHEN ZHEN  GUANG DONG  518126
				CN

94-FB-A7   (hex)		Rosenberger Technologies Co.,Ltd.
D00000-DFFFFF     (base 16)		Rosenberger Technologies Co.,Ltd.
				NO.6, ShenAn Rd, Dianshanhu Town
				Kunshan City  Jiangsu Province  215345
				CN

30-49-50   (hex)		Guangzhou Lian-med Technology Co.,Ltd.
000000-0FFFFF     (base 16)		Guangzhou Lian-med Technology Co.,Ltd.
				Room 501, Building G1,No. 31 Kefeng Road, Huangpu district
				Guangzhou    510670
				CN

30-49-50   (hex)		IoTmaxx GmbH
E00000-EFFFFF     (base 16)		IoTmaxx GmbH
				Bultstrasse 5a
				Hannover    30159
				DE

D0-14-11   (hex)		Ahnnet
600000-6FFFFF     (base 16)		Ahnnet
				B-313, Samhwan HIPEX, 230, Pangyoyeok-ro, Bundang-gu
				Seongnam-si  Gyeonggi-do  13493
				KR

1C-88-79   (hex)		ANDRA Sp. z o. o.
100000-1FFFFF     (base 16)		ANDRA Sp. z o. o.
				Pryzmaty 6/8
				Warszawa    02-226
				PL

D0-14-11   (hex)		Guangdong Shiqi Manufacture Co., Ltd.
D00000-DFFFFF     (base 16)		Guangdong Shiqi Manufacture Co., Ltd.
				No. D10~11, Lunjiao intensive industrial Zone,  Licun  Village committee, Lunjiao street office, Shunde District
				Foshan  Guangdong  528300
				CN

5C-85-7E   (hex)		Express LUCK Industrial Ltd.
900000-9FFFFF     (base 16)		Express LUCK Industrial Ltd.
				No. 88, Baotongnan Road, Xikeng, Yuanshan Street, Longgang District
				Shenzhen  Guangdong  518100
				CN

5C-85-7E   (hex)		Guoyi Liangzi (Hefei) Technology Co., Ltd(CIQTEK)
E00000-EFFFFF     (base 16)		Guoyi Liangzi (Hefei) Technology Co., Ltd(CIQTEK)
				1-4th Floor, Building No.E2, Chuangxin Industrial Park, No.2800, Chuangxin Road Gaoxin District
				Hefei   Anhui  Hefei 
				CN

F4-69-D5   (hex)		Nantong ZYDZ Electronic.,Co.Ltd
D00000-DFFFFF     (base 16)		Nantong ZYDZ Electronic.,Co.Ltd
				# F, High-Tech business Incubator, No.86 East Waihuan Road,
				Nantong  Jiangsu  226300
				CN

4C-93-A6   (hex)		Hanwang Technology Co.,Ltd
A00000-AFFFFF     (base 16)		Hanwang Technology Co.,Ltd
				HANVON TOWER, BUILDING NO.5, ZHONGGUANCUN SOFTWARE PARK, HAIDIAN DISTRICT, BEIJING, CHINA  100193 
				BEIJING  BEIJING  100193 
				CN

F4-69-D5   (hex)		Stype CS d.o.o.
400000-4FFFFF     (base 16)		Stype CS d.o.o.
				Velikopoljska 32
				Zagreb    10010
				HR

28-B7-7C   (hex)		AnyLink LLC
C00000-CFFFFF     (base 16)		AnyLink LLC
				100 N Washington St. Floor 6
				Boston  MA  02114
				US

28-B7-7C   (hex)		Shanghai Taiji Software Co.,Limited
600000-6FFFFF     (base 16)		Shanghai Taiji Software Co.,Limited
				Room J1224, No. 6, Lane 129, Huajiang Road, Jiading District
				Shanghai  Shanghai  201800
				CN

C0-61-9A   (hex)		LYAND ACOUSTIC TECHNOLOGY CO.,LTD.
300000-3FFFFF     (base 16)		LYAND ACOUSTIC TECHNOLOGY CO.,LTD.
				No. 73 JinFu Road XiaoJinKou
				Huizhou city   GuangDong  516023
				CN

28-B7-7C   (hex)		Enedo Finland Oy
D00000-DFFFFF     (base 16)		Enedo Finland Oy
				Martinkyläntie 43
				Vantaa    01720
				FI

C0-61-9A   (hex)		KidKraft
100000-1FFFFF     (base 16)		KidKraft
				4630 Olin Rd
				Dallas  TX  75244
				US

C0-61-9A   (hex)		Zhejiang Haikang Science And Technology Co.,Ltd
E00000-EFFFFF     (base 16)		Zhejiang Haikang Science And Technology Co.,Ltd
				No.797 Binkang Rd, Binjiang District
				Hangzhou    310053
				CN

C0-61-9A   (hex)		Paragon Robotics LLC
000000-0FFFFF     (base 16)		Paragon Robotics LLC
				5386 Majestic Pkwy Ste 2
				Bedford Heights  OH  44146
				US

C0-61-9A   (hex)		JAM-Labs Corp
C00000-CFFFFF     (base 16)		JAM-Labs Corp
				4109 Clipper Ct
				Fremont  CA  94538
				US

98-FC-84   (hex)		ZERONE CO., LTD.
600000-6FFFFF     (base 16)		ZERONE CO., LTD.
				Shinil IT UTO Bldg. #810, LS-ro 13, Gunpo-si, Gyeonggi-do, Korea
				SEOUL    15843
				KR

98-FC-84   (hex)		go-e GmbH
100000-1FFFFF     (base 16)		go-e GmbH
				Satellitenstrasse 1
				Feldkirchen  Kaernten  9560
				AT

18-FD-CB   (hex)		TRANSLITE GLOBAL LLC
B00000-BFFFFF     (base 16)		TRANSLITE GLOBAL LLC
				6644 ANTOINE DRIVE 
				HOUSTON  TX  77091
				US

98-FC-84   (hex)		Zymbit
500000-5FFFFF     (base 16)		Zymbit
				53 Cass Place, Suite B
				Goleta  CA  93117
				US

18-FD-CB   (hex)		CreyNox GmbH
900000-9FFFFF     (base 16)		CreyNox GmbH
				Autokaderstrasse 29, BT2
				Vienna    1210
				AT

58-20-8A   (hex)		SAMIL CTS Co., Ltd.
800000-8FFFFF     (base 16)		SAMIL CTS Co., Ltd.
				8F, Woolim Lion's Valley 3cha, 24 Dunchon Daero 388beon-gil, Jungwon-gu
				Seongnam-si  Gyeonggi-do, KOREA  13403
				KR

18-FD-CB   (hex)		Shenzhen Rui jiali Electronic Technology Co. Ltd.
000000-0FFFFF     (base 16)		Shenzhen Rui jiali Electronic Technology Co. Ltd.
				306 ROOM,Building B, ShenZhaoYe Science Park, BaoLong 5 Road No. 1,Baolong Industrial City ,Pingshan District
				Shenzhen    518118
				CN

18-FD-CB   (hex)		ENERGIE IP
700000-7FFFFF     (base 16)		ENERGIE IP
				48 rue du Château d’eau 
				Paris  Ile-de-France  75010
				FR

CC-4F-5C   (hex)		Shanghai Zenchant Electornics Co.,LTD
300000-3FFFFF     (base 16)		Shanghai Zenchant Electornics Co.,LTD
				Room 1202, building a, Noble international, 908 Xiuwen Road, Minhang District
				ShangHai  ShangHai  201199
				CN

CC-4F-5C   (hex)		Dtrovision
900000-9FFFFF     (base 16)		Dtrovision
				22-10 STATE RT 208
				Fair Lawn  NJ  07410
				US

CC-4F-5C   (hex)		AZ-TECHNOLOGY SDN BHD
A00000-AFFFFF     (base 16)		AZ-TECHNOLOGY SDN BHD
				A108 & A109 BLOCK A KELANA BUSINESS CENTRE NO: 97 JALAN SS7/2 KELANA JAYA
				PETALING JAYA  SELANGOR  47301
				MY

FC-CD-2F   (hex)		Shenzhen Smartbyte Technology Co., Ltd.
D00000-DFFFFF     (base 16)		Shenzhen Smartbyte Technology Co., Ltd.
				 6th Floor, Building D, Huiqing Science and Technology Park, No. 8 Dafu Industrial Zone, Guanlan Street, Longhua District, Shenzhen
				shenzhen  guangdong  518110
				CN

FC-CD-2F   (hex)		Siren Care(Shanghai) information and technology company
100000-1FFFFF     (base 16)		Siren Care(Shanghai) information and technology company
				Room 205, Floor 2, B Zone, Building 2, No 1899, Jiahao Rd, Jiading
				Shanghai    201802
				CN

FC-CD-2F   (hex)		Xmitech Technology Co., Limited
300000-3FFFFF     (base 16)		Xmitech Technology Co., Limited
				RM888, F8,Tower B,Xinnengyuan Building
				shenzhen    518054
				CN

FC-CD-2F   (hex)		Genitek Engineering sprl
400000-4FFFFF     (base 16)		Genitek Engineering sprl
				Rue Edouard Belin, 5
				Mont-Saint-Guibert    1435
				BE

58-95-D8   (hex)		shenzhen UDD Technologies,co.,Ltd
100000-1FFFFF     (base 16)		shenzhen UDD Technologies,co.,Ltd
				Unit D, 6th Floor, Jialitai Bldg., No.45 Yanshan Road, Shekou, Nanshan District, Shenzhen, China
				shenzhen  guangdong  51800
				CN

CC-4F-5C   (hex)		Beijing Neutron Technology CO.,LTD.
D00000-DFFFFF     (base 16)		Beijing Neutron Technology CO.,LTD.
				Beijing Neutron Technology CO.,LTD. 
				Beijing  Beijing  100193
				CN

DC-4A-9E   (hex)		Maxvision Technology Corp.
B00000-BFFFFF     (base 16)		Maxvision Technology Corp.
				16F,East Block,High-tech Plaza Phase II,Tianan Cyber Park,Futian District,Shenzhen.
				Shenzhen.    518000
				CN

58-95-D8   (hex)		elgris UG
500000-5FFFFF     (base 16)		elgris UG
				Langerweher Str. 10
				Inden  Deutschland  52459
				DE

DC-4A-9E   (hex)		Annapurna labs
200000-2FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

68-79-12   (hex)		ShangHai Aigentoo Information Technology Co., Ltd
800000-8FFFFF     (base 16)		ShangHai Aigentoo Information Technology Co., Ltd
				Room 1126,Building 1,Xin Ye Building,388 Tianlin Road,Xuhui District
				Shanghai    200080
				CN

68-79-12   (hex)		PCTEL, Inc.
000000-0FFFFF     (base 16)		PCTEL, Inc.
				471 Brighton Drive
				Bloomingdale  IL  60108
				US

68-79-12   (hex)		APPOTRONICS CO., LTD
600000-6FFFFF     (base 16)		APPOTRONICS CO., LTD
				4th Floor,SZICC,NO.1089,Chaguang Road,Nanshan District, Shenzhen, China
				Shenzhen  Guangdong  518000
				CN

84-11-C2   (hex)		Provision-ISR
C00000-CFFFFF     (base 16)		Provision-ISR
				11 Atir Yeda St.
				Kfar Saba  Israel  4464310
				IL

84-11-C2   (hex)		Goldmund Switzerland
D00000-DFFFFF     (base 16)		Goldmund Switzerland
				Chemin Grenet 21, 1214
				Vernier  Geneva  1214
				CH

84-11-C2   (hex)		Ei3 Corporation
700000-7FFFFF     (base 16)		Ei3 Corporation
				2 Blue Hill Plaza, Ste 1544
				Pearl River  NY  10965
				US

84-11-C2   (hex)		AIBIoT GmbH
500000-5FFFFF     (base 16)		AIBIoT GmbH
				Hornemannstr. 12
				Hildesheim  Lower Saxony  31137
				DE

8C-47-6E   (hex)		Shanghai Satellite Communication Technology Co.,Ltd
300000-3FFFFF     (base 16)		Shanghai Satellite Communication Technology Co.,Ltd
				Shanghai Satellite Communication Technology Co.,Ltd
				Shanghai  Shanghai  201800
				CN

8C-47-6E   (hex)		Square Inc.
500000-5FFFFF     (base 16)		Square Inc.
				1455 Market St.
				San Francisco  CA  94103
				US

68-79-12   (hex)		Stephan Electronics SARL
300000-3FFFFF     (base 16)		Stephan Electronics SARL
				Maupas 9
				Lausanne    1004
				CH

8C-47-6E   (hex)		Faravid Communication&Data Analysis
B00000-BFFFFF     (base 16)		Faravid Communication&Data Analysis
				18th unit, No.2, Houman Alley Abbaspour Av., 
				Vanak Sq.  Tehran  1435633413
				IR

8C-47-6E   (hex)		TelWare Corporation
100000-1FFFFF     (base 16)		TelWare Corporation
				1824 Industrial Center Circle
				Charlotte  NC  28213
				US

8C-47-6E   (hex)		Shenzhen Juding Electronics Co., Ltd.
400000-4FFFFF     (base 16)		Shenzhen Juding Electronics Co., Ltd.
				5th Floor, Building B5, Fenghuanggang Third Industrial Zone, No.231, Baotian 1st Road, Baoan District
				Shenzhen  Guangdong  518100
				CN

8C-47-6E   (hex)		Edge Networks Inc
C00000-CFFFFF     (base 16)		Edge Networks Inc
				943 W. Overland Road, Suite 152
				Meridian  ID  83642
				US

8C-47-6E   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

8C-AE-49   (hex)		Ouman Oy
000000-0FFFFF     (base 16)		Ouman Oy
				Voimatie 6
				Kempele    FIN-90440
				FI

8C-AE-49   (hex)		Jiangsu Sixingda Information Technology Co., Ltd.
400000-4FFFFF     (base 16)		Jiangsu Sixingda Information Technology Co., Ltd.
				Jiangsu Sixingda Information Technology Co., Ltd.
				Nanjing  Jiangsu  210000
				CN

8C-AE-49   (hex)		Suzhou Guowang Electronics Technology Co., Ltd.
B00000-BFFFFF     (base 16)		Suzhou Guowang Electronics Technology Co., Ltd.
				No. 99, Changli Road, 703, Wuzhong science and technology entrepreneurship Park
				Suzhou    215168
				CN

A4-53-EE   (hex)		Viper Design, LLC
B00000-BFFFFF     (base 16)		Viper Design, LLC
				85 Cude Lane
				Madison  TN  37115
				US

A0-02-4A   (hex)		Donguan Amsamotion Automation Technology Co., Ltd
500000-5FFFFF     (base 16)		Donguan Amsamotion Automation Technology Co., Ltd
				Block A, Zosun Intelligence Creation Zone, No.9 Yizhan Road, Yuanwubian Streeet Nancheng District,
				Dongguan  Gunagdong  523000
				CN

A0-02-4A   (hex)		Guangdong Jinpeng Technology Co. LTD
A00000-AFFFFF     (base 16)		Guangdong Jinpeng Technology Co. LTD
				Room 504, 5 / F, Self-built A3 Building, No. 50 Science Avenue, Huangpu District
				Guangzhou    510700
				CN

A0-02-4A   (hex)		Beijing Lyratone Technology Co., Ltd
800000-8FFFFF     (base 16)		Beijing Lyratone Technology Co., Ltd
				1st floor, Caigang building, No.40 Beiyuan Road
				Beijing    100020
				CN

A0-02-4A   (hex)		Encroute AB
C00000-CFFFFF     (base 16)		Encroute AB
				Box 2062
				Sundbyberg    17402
				SE

A0-02-4A   (hex)		Vitec Imaging Solutions Spa
100000-1FFFFF     (base 16)		Vitec Imaging Solutions Spa
				Via Valsugana 100
				Cassola  Vicenza  36022
				IT

78-D4-F1   (hex)		Jiangsu byzoro intelligent technology Co.,Ltd
B00000-BFFFFF     (base 16)		Jiangsu byzoro intelligent technology Co.,Ltd
				Room 301, Building D, Yunmi City, No.19 Ningshuang Road, Yuhuatai District
				Nanjing  Jiangsu  210012
				CN

44-6F-D8   (hex)		BAYKON Endüstriyel Kontrol Sistemleri San. ve Tic. A.Ş.
200000-2FFFFF     (base 16)		BAYKON Endüstriyel Kontrol Sistemleri San. ve Tic. A.Ş.
				Kimya Sanayicileri Org. San. Bolgesi Organik Cad. No:31
				Istanbul  Tuzla   34956
				TR

44-6F-D8   (hex)		ITC
700000-7FFFFF     (base 16)		ITC
				3030 Corporate Grove Drive
				Hudsonville  MI  49426
				US

44-6F-D8   (hex)		CTE
E00000-EFFFFF     (base 16)		CTE
				No. 1-7, Gongjian Rd., Cidu District, Keelung City 20647, Taiwan R.O.C
				Keelung  Taiwan  106
				TW

98-27-82   (hex)		INFODAS GmbH
100000-1FFFFF     (base 16)		INFODAS GmbH
				Rhonestr. 2
				Cologne    50765
				DE

98-27-82   (hex)		Anhui Shengren Electronic Technology Co., Ltd
200000-2FFFFF     (base 16)		Anhui Shengren Electronic Technology Co., Ltd
				520 Jiahe Road, Yuhui District
				Bengbu  Anhui  233000
				CN

98-27-82   (hex)		SureFlap Ltd
E00000-EFFFFF     (base 16)		SureFlap Ltd
				7 The Irwin Centre, Scotland Road, Dry Drayton
				Cambridge  Cambridgeshire  CB23 8AR
				GB

04-11-19   (hex)		CEITA COMMUNICATION TECHNOLOGY CO.,LTD
500000-5FFFFF     (base 16)		CEITA COMMUNICATION TECHNOLOGY CO.,LTD
				611, Renbao Building, 32 Baolong Road, Changlong Community, Buji Street, Longgang District
				Shenzhen  Guangdong  518000
				CN

98-27-82   (hex)		KRISTECH Krzysztof Kajstura
C00000-CFFFFF     (base 16)		KRISTECH Krzysztof Kajstura
				Porzeczkowa 12
				Ustro?  Please select region, state or province  43-450
				PL

04-11-19   (hex)		ZPD technology Co., Ltd
600000-6FFFFF     (base 16)		ZPD technology Co., Ltd
				2# Floor, 1# Gate?12# Building?5# Jiangtai Road, Chaoyang District,Beijing
				Beijing  Beijing  100015
				CN

E8-6C-C7   (hex)		ASSA ABLOY(GuangZhou) Smart Technology Co., Ltd
100000-1FFFFF     (base 16)		ASSA ABLOY(GuangZhou) Smart Technology Co., Ltd
				Plant Building 5, 106 Xieshi Highway, Shibi 1st Village
				Guangzhou  GuangDong  511495
				CN

04-11-19   (hex)		Haerbin Donglin Technology Co., Ltd.
C00000-CFFFFF     (base 16)		Haerbin Donglin Technology Co., Ltd.
				Room 2, Floor 1, Unit 6, Building 2,Yuanshi Street 35, Nangang District
				Haerbin  Heilongjiang  150000
				CN

04-11-19   (hex)		Bolicom Innovation Technology (BeiJing) Co.,LTD.
400000-4FFFFF     (base 16)		Bolicom Innovation Technology (BeiJing) Co.,LTD.
				Rm2327, Building23, No.18 Anningzhuang East Road, Haidian District
				Bei Jing    100000
				CN

24-5D-FC   (hex)		Shenzhen Hailuck Electronic Technology CO.,LTD
300000-3FFFFF     (base 16)		Shenzhen Hailuck Electronic Technology CO.,LTD
				2/F, building 19, Baotian industrial zone, the Third Baotian Road, Bao'an district
				Shenzhen  GuangDong  518101
				CN

E8-6C-C7   (hex)		MORNSUN Guangzhou Science & Technology Co., Ltd.
B00000-BFFFFF     (base 16)		MORNSUN Guangzhou Science & Technology Co., Ltd.
				No.5,Kehui St. 1,kehui Development Center,Science Ave.,Guangzhou Science City,  Huangpu District
				GuangZhou  GuangDong   510000
				CN

24-5D-FC   (hex)		ONLY
B00000-BFFFFF     (base 16)		ONLY
				1F., No. 16, Ln. 76, Zhongyang N. Rd., Sanchong Dist
				New Taipei City  Taiwan (R.O.C.)   24146
				TW

24-5D-FC   (hex)		Tata Sky Limited
A00000-AFFFFF     (base 16)		Tata Sky Limited
				Unit 301 to 305, 3rd Floor, Windsor, Off C.S.T. Road, Kalina, Santacruz (East), Mumbai – 400 098 
				Mumbai  Maharashtra  400098
				IN

94-05-BB   (hex)		Neutrik AG
300000-3FFFFF     (base 16)		Neutrik AG
				Im alten Riet 143
				Schaan  SCHAAN  9494
				LI

60-15-92   (hex)		Yangzhou Wanfang Electronic Technology,CO .,Ltd.
800000-8FFFFF     (base 16)		Yangzhou Wanfang Electronic Technology,CO .,Ltd.
				No.96 Anlin Road,Guangling District
				Yangzhou City  Jiangsu Province  225000
				CN

A4-53-EE   (hex)		Shenzhen Xunqi Interconnet Technology Co., Ltd
600000-6FFFFF     (base 16)		Shenzhen Xunqi Interconnet Technology Co., Ltd
				26G, block B, Haiwang building, Chuangye Road, Nanshan District,
				Shenzhen  Guangdong  518000
				CN

60-15-92   (hex)		Faster CZ spol. s r.o.
700000-7FFFFF     (base 16)		Faster CZ spol. s r.o.
				Jarní 44g
				Brno    61400
				CZ

60-15-92   (hex)		BEIJING KUANGSHI TECHNOLOGY CO., LTD
600000-6FFFFF     (base 16)		BEIJING KUANGSHI TECHNOLOGY CO., LTD
				Room 1018,10th Floor, No.1 Zhongguancun Street, Haidian District, 
				Beijing  Beijing  100086
				CN

0C-5C-B5   (hex)		BSU Inc
D00000-DFFFFF     (base 16)		BSU Inc
				1611 Headway Circle, Building 1, Suite 200
				Austin  TX  78754
				US

1C-A0-EF   (hex)		Atlas Aerospace
900000-9FFFFF     (base 16)		Atlas Aerospace
				Ulbrokas 19a
				Riga  Riga  LV-1021
				LV

0C-5C-B5   (hex)		Zhengzhou coal machinery hydraulic electric control Co.,Ltd
A00000-AFFFFF     (base 16)		Zhengzhou coal machinery hydraulic electric control Co.,Ltd
				167 Jingkai 9th Street, Zhengzhou Economic Development Zone
				Zhengzhou    45000
				CN

1C-A0-EF   (hex)		Henrich Electronics Corporation
A00000-AFFFFF     (base 16)		Henrich Electronics Corporation
				225 Deming Place
				Westmont    60559
				US

1C-A0-EF   (hex)		 BMK professional electronics GmbH
B00000-BFFFFF     (base 16)		 BMK professional electronics GmbH
				Werner-von-Siemens-Straße 6
				Augsburg     86159
				DE

1C-A0-EF   (hex)		Nanjing Bilin Intelligent Identification Technology Co.,Ltd
500000-5FFFFF     (base 16)		Nanjing Bilin Intelligent Identification Technology Co.,Ltd
				No.9 Bancang Street
				Nanjing  Jiangsu  210000
				CN

1C-A0-EF   (hex)		Schneider-Electric(China)Co.Ltd,Shenzhen Branch
200000-2FFFFF     (base 16)		Schneider-Electric(China)Co.Ltd,Shenzhen Branch
				Unit A to C 7/F and 8/F,CES Building ,No.3099,Keyuan South road, Nanshan Dist, Shenzhen, GD, China
				SHENZHEN    518000
				CN

1C-A0-EF   (hex)		RDA Microelectronics Technologies (Shanghai) Co. , Ltd
E00000-EFFFFF     (base 16)		RDA Microelectronics Technologies (Shanghai) Co. , Ltd
				Room 336, No.3, Lane 2288, Zuchongzhi Road, Pudong Area
				Shanghai  Shanghai  200120
				CN

20-CE-2A   (hex)		Annapurna labs
000000-0FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

20-CE-2A   (hex)		Cuculus GmbH
300000-3FFFFF     (base 16)		Cuculus GmbH
				Lindenstr. 9 -11
				Ilmenau  Thuringia  98693
				DE

20-CE-2A   (hex)		Annapurna labs
400000-4FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

20-CE-2A   (hex)		Radarxense BV
600000-6FFFFF     (base 16)		Radarxense BV
				Kwekerijweg, 2A
				Zeist  Nederland  3709 JA
				NL

78-C2-C0   (hex)		Sichuan Tianyi Comheart Telecom Co.,LTD
600000-6FFFFF     (base 16)		Sichuan Tianyi Comheart Telecom Co.,LTD
				FL12,TowerB,Tianyi international Hotel,No.2 West Section One, Second Ring Road, Chengdu, Sichuan
				Chengdu  Sichuan  610000
				CN

88-C9-B3   (hex)		Shenzhen Viewsmart Technology Co.,Ltd
C00000-CFFFFF     (base 16)		Shenzhen Viewsmart Technology Co.,Ltd
				Room 10C?Floor 10,South China Navigation Building, No.7 North Langshan Road,Nanshan District, Shenzhen, China.
				SHENZHEN    518000
				CN

88-C9-B3   (hex)		Hugo Techno
600000-6FFFFF     (base 16)		Hugo Techno
				F92 Green Park
				New Delhi  Delhi  110016
				IN

88-C9-B3   (hex)		Richbeam (Beijing) Technology Co., Ltd.
900000-9FFFFF     (base 16)		Richbeam (Beijing) Technology Co., Ltd.
				2608, Tower A, Tianzuo International, No.12, Zhongguancun South Street, Haidian District
				Beijing  Beijing  100081
				CN

C8-F5-D6   (hex)		HENAN FOXSTAR DIGITAL DISPLAY Co.,Ltd.
A00000-AFFFFF     (base 16)		HENAN FOXSTAR DIGITAL DISPLAY Co.,Ltd.
				No. 7 Bldg., Yulong Block, Longsheng Road, Optronic Industry Area, Nanyang,Henan,P.R.China
				Nanyang    473000
				CN

C8-F5-D6   (hex)		MEIRYO TECHNICA CORPORATION
000000-0FFFFF     (base 16)		MEIRYO TECHNICA CORPORATION
				2039-1,Shimoi, Shimoi-cho
				Owariasahi-city  Aichi  488-0052
				JP

C0-FB-F9   (hex)		Minato Advanced Technologies inc
400000-4FFFFF     (base 16)		Minato Advanced Technologies inc
				4105, Minami Yamata-cho, Tsuzuki-ku,
				YOKOHAMA  Kanagawa  224-0026
				JP

C0-FB-F9   (hex)		 LongSung Technology (Shanghai) Co.,Ltd.   
700000-7FFFFF     (base 16)		 LongSung Technology (Shanghai) Co.,Ltd.   
				 Room 606, Block B, Bldg. 1, No. 3000 Longdong Avenue., Zhangjiang Hi-Tech Park, Pudong District
				ShangHai    201203
				CN

C8-F5-D6   (hex)		HEITEC AG
E00000-EFFFFF     (base 16)		HEITEC AG
				Güterbahnhofstrasse 5
				Erlangen  Please select state  91052
				DE

C8-F5-D6   (hex)		BBPOS International Limited
300000-3FFFFF     (base 16)		BBPOS International Limited
				Suite 1602, Tower 2, Nina Tower, 8 Yeung Uk Road, Tsuen Wan, NT
				Hong Kong  China  00000
				HK

88-C9-B3   (hex)		Fortive Setra-ICG(Tianjin)Co.,Ltd
300000-3FFFFF     (base 16)		Fortive Setra-ICG(Tianjin)Co.,Ltd
				28 weiwu Road,Micro-electronics Industrial Park,Xiqing District Tianjin,P,R,China
				Tianjin    300380
				CN

C0-FB-F9   (hex)		Xerox Corporation
000000-0FFFFF     (base 16)		Xerox Corporation
				800 Phillips Rd, Mailstop 0207-2Z
				Webster  NY  14580
				US

C0-FB-F9   (hex)		zxsolution
900000-9FFFFF     (base 16)		zxsolution
				nanshan shenzhen
				shenzhen    518000
				CN

D0-9F-D9   (hex)		Westar Display Technologies
200000-2FFFFF     (base 16)		Westar Display Technologies
				4 Research Park Dr
				St Charles  MO  63304
				US

18-74-E2   (hex)		Sansec Technology Co.,Ltd
700000-7FFFFF     (base 16)		Sansec Technology Co.,Ltd
				Bejing Chaoyang District Guangshun North Street Hostpital No.16 No.2 building 14 room 1406
				Bejing   Bejing   100102
				CN

D0-9F-D9   (hex)		Cablewireless Laboratory Co., Ltd
B00000-BFFFFF     (base 16)		Cablewireless Laboratory Co., Ltd
				Room 218,  Block E1, Yuanchenxin Building, 12 Yumin Road, Chaoyang District
				Beijing    100029
				CN

18-74-E2   (hex)		CT Company
300000-3FFFFF     (base 16)		CT Company
				Godovikova , 9, Moscow
				Moscow  RUSSIA  129085
				RU

18-74-E2   (hex)		Ensor AG
000000-0FFFFF     (base 16)		Ensor AG
				Riedstrasse 11
				Cham  Zug  CH - 6330
				CH

E8-78-29   (hex)		Ryu Tech. LTD
900000-9FFFFF     (base 16)		Ryu Tech. LTD
				No.10 Lane 369,Yuan Taung Rd.JhoneHe City
				Taipei  Taiwan,R.O.C  235
				TW

E8-78-29   (hex)		Private
B00000-BFFFFF     (base 16)		Private

E8-78-29   (hex)		Galcon
200000-2FFFFF     (base 16)		Galcon
				Kfar Blum  israel
				Kfar Blum  Israel   121500
				IL

18-74-E2   (hex)		Private
400000-4FFFFF     (base 16)		Private

E8-78-29   (hex)		SHEN ZHEN SKYSI WISDOM TECHNOLOGY CO.,LTD.
500000-5FFFFF     (base 16)		SHEN ZHEN SKYSI WISDOM TECHNOLOGY CO.,LTD.
				Room 1106,11th floor, National Technology Building, no. 109, Baoshen Road, Songpingshan community, Xili Street, Nanshan district, Shenzhen City
				SHENZHEN  GUANGDONG  518000
				CN

E8-78-29   (hex)		FairPhone B.V.
C00000-CFFFFF     (base 16)		FairPhone B.V.
				VanDiemenstraat 200
				Amsterdam    1013 CP
				NL

B4-4B-D6   (hex)		Shenzhen Cudy Technology Co., Ltd.
200000-2FFFFF     (base 16)		Shenzhen Cudy Technology Co., Ltd.
				Room A606, Gaoxinqi Industrial Park, Baoan 67 Dist
				Baoan 67 District, Shenzhen    518101
				CN

A8-5B-36   (hex)		PARMA LLC
100000-1FFFFF     (base 16)		PARMA LLC
				Leninsky Prospekt, 140, lit A, room 15N
				Saint Petersburg  Saint Petersburg  198216
				RU

78-13-05   (hex)		Shenzhen C & D Electronics Co., Ltd.
900000-9FFFFF     (base 16)		Shenzhen C & D Electronics Co., Ltd.
				9th FIoor, Building 9, No.1 Qingxiang road, BaoNeng Science and TechnoIogy Industrial Park, Longhua New District
				ShenZhen  GuangDong  518000
				CN

78-13-05   (hex)		Dongguan zhenxing electronic technology co.,limited
E00000-EFFFFF     (base 16)		Dongguan zhenxing electronic technology co.,limited
				GuangMingGang JinJun road 8#
				DonggUAN    523768
				CN

A8-5B-36   (hex)		Adam Hall GmbH
D00000-DFFFFF     (base 16)		Adam Hall GmbH
				Adam-Hall-Str. 1
				Neu-Anspach  Hessen  61267
				DE

F0-2A-2B   (hex)		Tenways Engineering Service Ltd
800000-8FFFFF     (base 16)		Tenways Engineering Service Ltd
				85 Kenilworth Road
				Edgware  Middlesex  HA8 8XA
				GB

44-A9-2C   (hex)		NetX Networks a.s.
400000-4FFFFF     (base 16)		NetX Networks a.s.
				Palackeho trida 811/112
				Brno  Czech Republic  62100
				CZ

F0-2A-2B   (hex)		Shenzhen CUCO Technology Co., Ltd
E00000-EFFFFF     (base 16)		Shenzhen CUCO Technology Co., Ltd
				Room 201, 301, Building A, No.12, Difu Road, Guxing Community, Xixiang Street, Baoan District
				Shenzhen  Guangdong  418000
				CN

44-A9-2C   (hex)		uimcom
100000-1FFFFF     (base 16)		uimcom
				Yingying building, 99 Tuanjie Road, Pukou District, Nanjing
				nanjing    211800
				CN

44-A9-2C   (hex)		Efficient Building Automation Corp.
700000-7FFFFF     (base 16)		Efficient Building Automation Corp.
				Unit 1004 - 7495 132nd Street
				Surrey  British Columbia  V3W1J8
				CA

58-48-49   (hex)		Waoo
A00000-AFFFFF     (base 16)		Waoo
				True Møllevej 9
				Tilst  Aarhus Municipallity  8381
				DK

64-33-B5   (hex)		ABB Electrification Smart Power (ELSP)
700000-7FFFFF     (base 16)		ABB Electrification Smart Power (ELSP)
				PVT. BAG 92609, SYMONDS STREET
				Auckland    1150
				NZ

64-33-B5   (hex)		Eagle Eye Networks, Inc
400000-4FFFFF     (base 16)		Eagle Eye Networks, Inc
				4611 Bee Cave Rd Suite 200
				austin  TX  78746
				US

64-33-B5   (hex)		LACO Technologies
800000-8FFFFF     (base 16)		LACO Technologies
				3085 W Directors Row
				Salt Lake City  UT  84104
				US

64-33-B5   (hex)		electroCore Inc.
B00000-BFFFFF     (base 16)		electroCore Inc.
				205 Forge Way
				Rockaway  NJ  07866
				US

64-33-B5   (hex)		MICROIT SRL
600000-6FFFFF     (base 16)		MICROIT SRL
				Via Galileo Galilei 1
				Medolla  MODENA  41036
				IT

64-33-B5   (hex)		Annapurna labs
900000-9FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

28-36-13   (hex)		Fuzhou Lesi Intelligent Technology Co., Ltd
800000-8FFFFF     (base 16)		Fuzhou Lesi Intelligent Technology Co., Ltd
				Room 1-3-5, north 9 / F, building 1, Fujian hi tech Pioneer Park, 611 Gongye Road, Gulou District
				Fuzhou  Fujian  350000
				CN

28-36-13   (hex)		midBit Technologies, LLC
C00000-CFFFFF     (base 16)		midBit Technologies, LLC
				153 Homestead Ln
				Romney  WV  26757
				US

28-36-13   (hex)		Turing Video
500000-5FFFFF     (base 16)		Turing Video
				1730 S El Camino Real, Suite 350
				San Mateo  CA  94402
				US

28-36-13   (hex)		MAKEEN Energy
A00000-AFFFFF     (base 16)		MAKEEN Energy
				Alsvej 21
				Randers    8940
				DK

28-36-13   (hex)		EGMedical, s.r.o.
E00000-EFFFFF     (base 16)		EGMedical, s.r.o.
				KRENOVA 19
				Brno  JHMK  60200
				CZ

28-36-13   (hex)		Qorvo, Inc.
B00000-BFFFFF     (base 16)		Qorvo, Inc.
				500 W. Renner Road
				Richardson  TX  75080
				US

78-5E-E8   (hex)		FINETOOLING TECHNOLOGY(HONG KONG)CO.,LIMITED
C00000-CFFFFF     (base 16)		FINETOOLING TECHNOLOGY(HONG KONG)CO.,LIMITED
				RM 1003 10/F TOWER 1 LIPPO CENTER 89 QUEENSWAY ADMIRALTY HK
				HONG KONG  HONG KONG  999077
				CN

38-A8-CD   (hex)		Annapurna labs
D00000-DFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

78-5E-E8   (hex)		Tachyon Networks
D00000-DFFFFF     (base 16)		Tachyon Networks
				11275 US HWY 98 W, STE. 6-259
				Miramar Beach  FL  32550
				US

78-5E-E8   (hex)		beijing Areospace Hongda optoelectronics technology co.,ltd
400000-4FFFFF     (base 16)		beijing Areospace Hongda optoelectronics technology co.,ltd
				Room 422, No.4, North Row, No.28 South Yard
				Beijing    Dongbei Wang Village, Dongbei Wang Township, Haidian District  065599
				CN

38-A8-CD   (hex)		Fujica System Co., ltd
100000-1FFFFF     (base 16)		Fujica System Co., ltd
				Building 6, JiuXiangLing Industrial Area, Xili street, Nanshan District,
				Shenzhen  GuangDong  518055
				CN

7C-83-34   (hex)		Beijing Changkun Technology Co., Ltd.
300000-3FFFFF     (base 16)		Beijing Changkun Technology Co., Ltd.
				Room 821-1, unit 2, floor 10, building 1, No. 3, Rongjing East Street, Beijing Economic Development Zone
				Beijing  Beijing  100176
				CN

7C-83-34   (hex)		ChengDU Yi Gong Intelligence Technology Co., Ltd.
700000-7FFFFF     (base 16)		ChengDU Yi Gong Intelligence Technology Co., Ltd.
				5th floor, building 4, No. 200, Tianfu 5th Street
				ChengDu  SiChuan  610000
				CN

7C-83-34   (hex)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
900000-9FFFFF     (base 16)		SERNET (SUZHOU) TECHNOLOGIES CORPORATION
				NO.8 Tangzhuang Road,Suzhou Industrial Park,Su ZhouCity,JiangSu Province,China
				Suzhou    215021
				CN

7C-83-34   (hex)		MSV elektronika s.r.o.
D00000-DFFFFF     (base 16)		MSV elektronika s.r.o.
				Postovni 662
				Studenka    742 13
				CZ

98-6E-E8   (hex)		Changzhou Jiahao Radio&TV device CO.,LTD
D00000-DFFFFF     (base 16)		Changzhou Jiahao Radio&TV device CO.,LTD
				NO.155,Jiaxing road
				Changzhou  Jiangsu  213000
				CN

98-6E-E8   (hex)		SUZHOU AUDITORYWORKS CO., LTD.
500000-5FFFFF     (base 16)		SUZHOU AUDITORYWORKS CO., LTD.
				Creative Industry Park, No.328, Xinghu Street, Suzhou Industrial Park, Unit 2-B504
				Suzhou  Jiangsu  215000
				CN

1C-AE-3E   (hex)		China Convert Technology Co., Ltd.
900000-9FFFFF     (base 16)		China Convert Technology Co., Ltd.
				Room 405,18 Building,No. 3333, Huaning Street, Minhang District
				Shanghai    210036
				CN

98-6E-E8   (hex)		Centro de Pesquisas Av Wernher Von Braun
700000-7FFFFF     (base 16)		Centro de Pesquisas Av Wernher Von Braun
				Avenida Alice de Castro Pupo Nogueira, Mattosinho, 301 - Alphaville
				campinas  Sao Paulo  13098392
				BR

98-80-BB   (hex)		Annapurna labs
300000-3FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

98-80-BB   (hex)		Shenzhen Xin Kingbrand Enterprises Co., Ltd
C00000-CFFFFF     (base 16)		Shenzhen Xin Kingbrand Enterprises Co., Ltd
				First and Third Floor of Building B,Building A, NO. 90 Nanpu Road, Shajing Street, Baoan District
				Shenzhen    518000
				CN

98-80-BB   (hex)		Wyebot, Inc.
D00000-DFFFFF     (base 16)		Wyebot, Inc.
				2 Mount Royal Ave.
				Marlborough  MA  01752
				US

78-72-64   (hex)		Typhoon HIL, Inc.
A00000-AFFFFF     (base 16)		Typhoon HIL, Inc.
				15 Ward Street, 2nd Floor
				Somerville    02143
				US

78-72-64   (hex)		Conjing Networks Inc.
700000-7FFFFF     (base 16)		Conjing Networks Inc.
				4F., No.108, Zhenxing Rd., East Dist.
				Hsinchu City    300081
				TW

78-72-64   (hex)		Asustor Inc.
400000-4FFFFF     (base 16)		Asustor Inc.
				3F, No.136, Daye Road, Beitou Dist.,
				Taipei City    112
				TW

F4-70-0C   (hex)		HYUNSUNG CONVERGENCE 
000000-0FFFFF     (base 16)		HYUNSUNG CONVERGENCE 
				802-Ho,Sanbon-ro,48beon-gil 32
				Gunpo-si  Gyeonggi-do  15846
				KR

F4-70-0C   (hex)		Shenzhen WeProTalk Technology Co., Ltd.
E00000-EFFFFF     (base 16)		Shenzhen WeProTalk Technology Co., Ltd.
				Room 201, R3-B building, Virtual univessity park, Nanshan
				Shenzhen   Guangdong  518000
				CN

F4-70-0C   (hex)		Shenzhen Anycon Electronics Technology Co.,Ltd
400000-4FFFFF     (base 16)		Shenzhen Anycon Electronics Technology Co.,Ltd
				1109,11th floor, Tower E, Galaxy world, Minle community, Minzhi, Longhua district
				Shenzhen  Guangdong  518100
				CN

F4-70-0C   (hex)		Shanghai Risingpo Electronics CO.,LTD
B00000-BFFFFF     (base 16)		Shanghai Risingpo Electronics CO.,LTD
				Room 501, Building 5, Lingang Excellence Industrial Park, No. 877, Jiuxin Road, Jiuting Town, Songjiang District, Shanghai
				shanghai    201615
				CN

F4-A4-54   (hex)		Introl Design
600000-6FFFFF     (base 16)		Introl Design
				4883 ida park drive
				Lockport  NY  14094
				US

F4-A4-54   (hex)		Chongqing Hengxun Liansheng Industrial Co.,Ltd
300000-3FFFFF     (base 16)		Chongqing Hengxun Liansheng Industrial Co.,Ltd
				Shop 42, Area C, Chongqing Yixiang City, No. 12 Jiangnan Avenue, Nan'an District
				Chongqing  Chongqing Province  404100
				CN

F4-A4-54   (hex)		NKT Photonics A/S
000000-0FFFFF     (base 16)		NKT Photonics A/S
				Blokken 84
				Birkerod    3460
				DK

18-45-B3   (hex)		Shenzhen Incar Technology Co., Ltd.
700000-7FFFFF     (base 16)		Shenzhen Incar Technology Co., Ltd.
				Zhongxi ECO International Building, Shuiku Rd., Baoan District
				Shenzhen     518000
				CN

F4-A4-54   (hex)		TRI WORKS
200000-2FFFFF     (base 16)		TRI WORKS
				#402 Goto building 4F 2-2-2 Daimyo Chuo-ku
				Fukuoka-shi    810-0041
				JP

08-F8-0D   (hex)		Shenzhen DophiGo IoT Technology Co.,Ltd
100000-1FFFFF     (base 16)		Shenzhen DophiGo IoT Technology Co.,Ltd
				B02, first floor, building No.9, Nanshan Yungu start-up business industrial park second part, No.2, Pingshan first road, Pingshan Community, Taoyuan Street, Nanshan district
				Shenzhen    518000
				CN

08-F8-0D   (hex)		OpenYard LLC
800000-8FFFFF     (base 16)		OpenYard LLC
				82, Sadovnicheskaya str., Building 2, Office 3F07
				Moscow    115035
				RU

04-EE-E8   (hex)		Shenzhen JoiningFree Technology Co.,Ltd
A00000-AFFFFF     (base 16)		Shenzhen JoiningFree Technology Co.,Ltd
				16F, Block C, Qifengda Building, Taohuayuan Science and Technology Innovation Park, Furong Road, Songgang Street, Baoan District,
				Shenzhen  Guangdong  518110
				CN

18-D7-93   (hex)		DongGuan Orient Electronics & Metal Co.,Ltd
500000-5FFFFF     (base 16)		DongGuan Orient Electronics & Metal Co.,Ltd
				A2 Building, ZhiGu Science and Technology Park, Gekeng industrial park, HengLi Town,  China
				DongGuan  GuangDong,  523468
				CN

04-EE-E8   (hex)		MPEON Co.,Ltd
800000-8FFFFF     (base 16)		MPEON Co.,Ltd
				#927, Gyeonggi business Growh Center, Pangyo 2nd TechnoValley, 42, Changeop-ro, Sujeong-gu
				Seongnam-si  Gyeonggi-do  13449
				KP

18-D7-93   (hex)		JFA Electronics Industry and Commerce EIRELI
700000-7FFFFF     (base 16)		JFA Electronics Industry and Commerce EIRELI
				Rua Flor das Pedras, 175
				Belo Horizonte  Minas Gerais  30810-000
				BR

18-D7-93   (hex)		Hydrotechnik GmbH
200000-2FFFFF     (base 16)		Hydrotechnik GmbH
				Holzheimer Strasse  94-96
				Limburg    65549
				DE

DC-36-43   (hex)		Orlaco Products B.V.
C00000-CFFFFF     (base 16)		Orlaco Products B.V.
				Albert Plesmanstraat 42
				Barneveld    3772MN
				NL

DC-36-43   (hex)		OAK INFORMATION SYSTEM CO.
800000-8FFFFF     (base 16)		OAK INFORMATION SYSTEM CO.
				2-2-20 Higashishinagawa
				Shinagawa-ku  Tokyo  140-0002
				JP

DC-36-43   (hex)		KUANTECH (CAMBODIA) CORPORATION LIMITED
A00000-AFFFFF     (base 16)		KUANTECH (CAMBODIA) CORPORATION LIMITED
				PHUM CHORMPUL, KHUM P'PEL, SROK TRAMKORK
				KINGDOM OF CAMBODIA  TAKEO PROVINCE  210209
				KH

08-26-AE   (hex)		Veth Propulsion bv
D00000-DFFFFF     (base 16)		Veth Propulsion bv
				Nanengat 17
				Papendrecht    3356AA
				NL

08-26-AE   (hex)		Mass Electronics Pty Ltd
E00000-EFFFFF     (base 16)		Mass Electronics Pty Ltd
				12 McKechnie Drive
				Eight Mile Plains  QLD  4113
				AU

98-8F-E0   (hex)		China Huaxin Post and Telecom Technologies Co., Ltd.
700000-7FFFFF     (base 16)		China Huaxin Post and Telecom Technologies Co., Ltd.
				5F, Building 1, Lane 60 Na Xian Road, Pudong District, Shanghai 201210 P.R.China
				Shanghai    200127
				CN

98-8F-E0   (hex)		CEL Terminus (Shanghai) Information Technologies Co.,Ltd.
E00000-EFFFFF     (base 16)		CEL Terminus (Shanghai) Information Technologies Co.,Ltd.
				18F, Building 2, CES West Bund Center, No.277 Longlan Rd, Xuhui District,
				Shanghai    200000
				CN

10-54-D2   (hex)		Annapurna labs
800000-8FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

10-54-D2   (hex)		Lanao Communication Technology Limited
600000-6FFFFF     (base 16)		Lanao Communication Technology Limited
				#B2, Zhongbaotong Creative Park Changfa West Road No.34 Bantian
				Shenzhen    518029
				CN

0C-86-29   (hex)		Ag Express Electronics
400000-4FFFFF     (base 16)		Ag Express Electronics
				6280 NE 14th St
				Des Moines  IA  50313
				US

6C-93-08   (hex)		Liberty AV Solutions
700000-7FFFFF     (base 16)		Liberty AV Solutions
				1490 Garden of the Gods Road
				Colorado Springs  CO  80907
				US

0C-86-29   (hex)		Annapurna labs
300000-3FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

6C-93-08   (hex)		Hangzhou Risco System Co.,Ltd
800000-8FFFFF     (base 16)		Hangzhou Risco System Co.,Ltd
				No. 19, Naxian street, Liangzhu street, Yuhang District
				Hangzhou City  Zhejiang Province  31000
				CN

6C-93-08   (hex)		Uconfree technology(shenzhen)limited
600000-6FFFFF     (base 16)		Uconfree technology(shenzhen)limited
				Room 311 PuFeng commercial center PingHu street LongGang District ShenZhen China
				SHENZHEN    518111
				CN

6C-93-08   (hex)		ZHEJIANG XIAN DA Environmental Technology Co., Ltd
200000-2FFFFF     (base 16)		ZHEJIANG XIAN DA Environmental Technology Co., Ltd
				Room 103,1st F,unit A,Buliding 3,No. 8,Xiyuan 1st Road,Sandun Town,Xihu District
				HANGZHOU  ZHEJIANG  310000
				CN

30-43-D7   (hex)		PK Solutions LLC
900000-9FFFFF     (base 16)		PK Solutions LLC
				10811 E Harry
				Wichita  KS  67207
				US

30-43-D7   (hex)		Bodhi
A00000-AFFFFF     (base 16)		Bodhi
				3150 W. Prospect Road, Suite 330
				Fort Lauderdale  FL  33309
				US

30-43-D7   (hex)		Kesu (Shanghai) Electronic Technology Co., Ltd
800000-8FFFFF     (base 16)		Kesu (Shanghai) Electronic Technology Co., Ltd
				3-36588?No. 1800, Panyuan Road, Changxing Town, Chongming District
				Shanghai    202150
				CN

38-1F-26   (hex)		NOITAC sp. z o.o. sp.k.
600000-6FFFFF     (base 16)		NOITAC sp. z o.o. sp.k.
				Szlak 28/3
				Kraków    31-153
				PL

38-1F-26   (hex)		JAESUNG INFORMATION & COMMUNICATION CO.LTD
000000-0FFFFF     (base 16)		JAESUNG INFORMATION & COMMUNICATION CO.LTD
				41-69, POWOL SAEMALGIL, YANG YANG-EUP
				YANG YANG GUN    25017
				KR

30-43-D7   (hex)		FIBERME COMMUNICATIONS LLC
400000-4FFFFF     (base 16)		FIBERME COMMUNICATIONS LLC
				1749 Old Meadow Rd.
				McLean  VA  22102
				US

38-1F-26   (hex)		Deutronic Elektronik GmbH
B00000-BFFFFF     (base 16)		Deutronic Elektronik GmbH
				Deutronicstraße 5
				Adlkofen  Bayern  84166
				DE

38-1F-26   (hex)		Annapurna labs
E00000-EFFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

38-1F-26   (hex)		RCE systems s.r.o.
700000-7FFFFF     (base 16)		RCE systems s.r.o.
				Svatopluka Cecha 2008/1d
				Brno  CR  61200
				CZ

38-1F-26   (hex)		Sercomm Corporation.
A00000-AFFFFF     (base 16)		Sercomm Corporation.
				3F,No.81,Yu-Yih Rd.,Chu-Nan Chen
				Miao-Lih Hsuan    115
				TW

30-43-D7   (hex)		Motec GmbH
B00000-BFFFFF     (base 16)		Motec GmbH
				287 27 Road
				Grand Junction  CO  81503
				US

CC-4F-5C   (hex)		Beijing Techao Weijia Technology Limited
E00000-EFFFFF     (base 16)		Beijing Techao Weijia Technology Limited
				Room 202, Floor 2, Building No. 3, No. 9 Xiaoying Road, Chaoyang District
				Beijing    100101
				CN

1C-59-74   (hex)		Council Rock
A00000-AFFFFF     (base 16)		Council Rock
				11 Centre Park
				Rochester    14614
				US

C4-A1-0E   (hex)		Hainan World Electronic Science and Techology Co.,Ltd
600000-6FFFFF     (base 16)		Hainan World Electronic Science and Techology Co.,Ltd
				Room 1502,15th Floor,Building 20,NO.487 Tianlin Road,Shanghai,200233 China
				Shanghai  Shanghai  200233
				CN

C4-A1-0E   (hex)		Jiangsu Perceive World Technology Co.,Ltd.
A00000-AFFFFF     (base 16)		Jiangsu Perceive World Technology Co.,Ltd.
				4-5F,Hengsheng Science Park 70#,Zhonghui Ave 1588#,HuiShan District,Wuxi,Jiangsu,China
				Wu xi  Jiangsu  214181
				CN

78-D4-F1   (hex)		Silla Industries
100000-1FFFFF     (base 16)		Silla Industries
				Via della Meccanica 2a
				Padova  PD  35127
				IT

18-A5-9C   (hex)		Cuman
100000-1FFFFF     (base 16)		Cuman
				Al-Farabi 97/1
				Nur-Sultan    010000
				KZ

6C-15-24   (hex)		STERIS
A00000-AFFFFF     (base 16)		STERIS
				Unit 7 & 8, Stortford Hall Industrial Park, Dunmow Road
				Bishops Stortford  herts  CM23 5GZ
				GB

C4-A1-0E   (hex)		XI'AN YEP TELECOM TECHNOLOGY CO.,LTD
900000-9FFFFF     (base 16)		XI'AN YEP TELECOM TECHNOLOGY CO.,LTD
				No.211 Tiangu 8th Road, High-tech Zone
				Xi 'an   Shaanxi  710065
				CN

C4-A1-0E   (hex)		Alio, Inc
E00000-EFFFFF     (base 16)		Alio, Inc
				10901 W. 120th Ave, Suite 380
				Bloomfield  CO  80021
				US

70-50-E7   (hex)		Wall Box Chargers, S.L.
500000-5FFFFF     (base 16)		Wall Box Chargers, S.L.
				Paseo Castellana 95, 28 floor
				Madrid  Madrid  28046
				ES

70-50-E7   (hex)		Guangzhou Tianhe High Tech Industrial Development Zone Zhongsheng Electrical Limited Company
A00000-AFFFFF     (base 16)		Guangzhou Tianhe High Tech Industrial Development Zone Zhongsheng Electrical Limited Company
				D01, Zone D, No. 6 (Yishun), Huangcun North Road, Tianhe District
				Guangzhou    510660
				CN

70-50-E7   (hex)		Electronic's Time SRL
200000-2FFFFF     (base 16)		Electronic's Time SRL
				Via Madonna Piccola 32R/Q
				Martina Franca  Taranto  74015
				IT

70-50-E7   (hex)		Yoctopuce
700000-7FFFFF     (base 16)		Yoctopuce
				Route de Cartigny 33
				Cartigny    1236
				CH

70-50-E7   (hex)		Skychers Creations ShenZhen Limited
300000-3FFFFF     (base 16)		Skychers Creations ShenZhen Limited
				Room 907A, 9/F, Block T2, FongDa City, Longjing Village, Longzhu Avenue, Nanshan District
				Shenzhen  Guangdong  518073
				CN

70-50-E7   (hex)		Elastics.cloud
900000-9FFFFF     (base 16)		Elastics.cloud
				1730 North First Street, 5th Floor
				San Jose  CA  95112
				US

80-02-F4   (hex)		Annapurna labs
800000-8FFFFF     (base 16)		Annapurna labs
				Matam Scientific Industries Center,   Building 8.2
				Mail box 15123  Haifa  3508409
				IL

8C-51-09   (hex)		Avxav Electronic Trading LLC
600000-6FFFFF     (base 16)		Avxav Electronic Trading LLC
				Office 534 Building # 6WA Dubai Airport Free Zone
				Dubai  Dubai  33964
				AE

80-02-F4   (hex)		Lazer Safe Pty Ltd
700000-7FFFFF     (base 16)		Lazer Safe Pty Ltd
				27 Action Road
				Perth  WA  6090
				AU

80-02-F4   (hex)		Beijing Cybercore
200000-2FFFFF     (base 16)		Beijing Cybercore
				A206,F2,Yard#12,Building#1,JingAn DongLi,Chaoyang
				Beijing  Beijing  100028
				CN

8C-51-09   (hex)		SHENZHEN LDROBOT CO., LTD.
300000-3FFFFF     (base 16)		SHENZHEN LDROBOT CO., LTD.
				Nanshan
				Shenzhen    518000
				CN

8C-51-09   (hex)		nerospec
800000-8FFFFF     (base 16)		nerospec
				9 Freda Road, Bromhof,Skyview Retail Park
				Randburg  Gauteng  2169
				ZA

8C-51-09   (hex)		Surpedia Technologies Co., Ltd.
D00000-DFFFFF     (base 16)		Surpedia Technologies Co., Ltd.
				5F-1, No.212, Sec 3, Datong Rd.
				Xhzhi Dist.  New Taipei City  22103
				TW

8C-51-09   (hex)		IROOTELLUCKY Corp.
E00000-EFFFFF     (base 16)		IROOTELLUCKY Corp.
				609ho, 13, LS-ro
				Gunpo-si  Gyeonggi-do  15843
				KR

0C-7F-ED   (hex)		Shenzhen MoreSense Technology Co., Ltd. 
C00000-CFFFFF     (base 16)		Shenzhen MoreSense Technology Co., Ltd. 
				#206 Building A1,#663 Bulong Road,Dafapu Community,Bantian Street,
				Shenzhen  Guangdong  518129
				CN

0C-7F-ED   (hex)		Grandway Technology (Shenzhen) Limited
700000-7FFFFF     (base 16)		Grandway Technology (Shenzhen) Limited
				Block 7, Zhu Keng Industrial Zone
				Ping Shan District  Shenzhen  518118
				CN

0C-7F-ED   (hex)		TelX Systems
B00000-BFFFFF     (base 16)		TelX Systems
				UMM RAMOOL
				DEIRA  DUBAI  48235
				AE

FC-61-79   (hex)		Int'Act Pty Ltd
D00000-DFFFFF     (base 16)		Int'Act Pty Ltd
				4 Pine Street
				North Ipswich  Queensland  4305
				AU

0C-7F-ED   (hex)		Toast, Inc.
100000-1FFFFF     (base 16)		Toast, Inc.
				401 Park Drive, Suite 801
				Boston  MA  02215
				US

FC-61-79   (hex)		Signalinks Communication Technology Co.,Ltd
100000-1FFFFF     (base 16)		Signalinks Communication Technology Co.,Ltd
				3rd Floor, Building 6, Longxing Sciece park, East Huaning Road, Dalang Street , Longhua District, Shenzhen
				Shenzhen  Guangdong  518000
				CN

FC-61-79   (hex)		Shenzhen Dptek Technology Co., Ltd.
A00000-AFFFFF     (base 16)		Shenzhen Dptek Technology Co., Ltd.
				Room 706, Building Pincui, Zhongcui Garden,Dafen Community, Buji Street, Longgang District
				Shenzhen  Guangdong  518000
				CN
