CN112064122A - 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法 - Google Patents

一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法 Download PDF

Info

Publication number
CN112064122A
CN112064122A CN202011059870.8A CN202011059870A CN112064122A CN 112064122 A CN112064122 A CN 112064122A CN 202011059870 A CN202011059870 A CN 202011059870A CN 112064122 A CN112064122 A CN 112064122A
Authority
CN
China
Prior art keywords
dna
artificial sequence
library
endometrial cancer
throughput sequencing
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
CN202011059870.8A
Other languages
English (en)
Other versions
CN112064122B (zh
Inventor
陈志宏
肖冰
陈琰
康灿昆
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Xiamen Spacegen Co ltd
Original Assignee
Xiamen Spacegen Co ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Xiamen Spacegen Co ltd filed Critical Xiamen Spacegen Co ltd
Priority to CN202011059870.8A priority Critical patent/CN112064122B/zh
Priority to US17/430,315 priority patent/US20220307016A1/en
Priority to PCT/CN2020/125277 priority patent/WO2022067938A1/zh
Publication of CN112064122A publication Critical patent/CN112064122A/zh
Application granted granted Critical
Publication of CN112064122B publication Critical patent/CN112064122B/zh
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • C—CHEMISTRY; METALLURGY
    • C40—COMBINATORIAL TECHNOLOGY
    • C40B—COMBINATORIAL CHEMISTRY; LIBRARIES, e.g. CHEMICAL LIBRARIES
    • C40B50/00—Methods of creating libraries, e.g. combinatorial synthesis
    • C40B50/06—Biochemical methods, e.g. using enzymes or whole viable microorganisms
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12N—MICROORGANISMS OR ENZYMES; COMPOSITIONS THEREOF; PROPAGATING, PRESERVING, OR MAINTAINING MICROORGANISMS; MUTATION OR GENETIC ENGINEERING; CULTURE MEDIA
    • C12N15/00—Mutation or genetic engineering; DNA or RNA concerning genetic engineering, vectors, e.g. plasmids, or their isolation, preparation or purification; Use of hosts therefor
    • C12N15/09—Recombinant DNA-technology
    • C12N15/10—Processes for the isolation, preparation or purification of DNA or RNA
    • C12N15/1034—Isolating an individual clone by screening libraries
    • C12N15/1093—General methods of preparing gene libraries, not provided for in other subgroups
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12N—MICROORGANISMS OR ENZYMES; COMPOSITIONS THEREOF; PROPAGATING, PRESERVING, OR MAINTAINING MICROORGANISMS; MUTATION OR GENETIC ENGINEERING; CULTURE MEDIA
    • C12N15/00—Mutation or genetic engineering; DNA or RNA concerning genetic engineering, vectors, e.g. plasmids, or their isolation, preparation or purification; Use of hosts therefor
    • C12N15/09—Recombinant DNA-technology
    • C12N15/11—DNA or RNA fragments; Modified forms thereof; Non-coding nucleic acids having a biological activity
    • C12N15/111—General methods applicable to biologically active non-coding nucleic acids
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12Q—MEASURING OR TESTING PROCESSES INVOLVING ENZYMES, NUCLEIC ACIDS OR MICROORGANISMS; COMPOSITIONS OR TEST PAPERS THEREFOR; PROCESSES OF PREPARING SUCH COMPOSITIONS; CONDITION-RESPONSIVE CONTROL IN MICROBIOLOGICAL OR ENZYMOLOGICAL PROCESSES
    • C12Q1/00—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions
    • C12Q1/68—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions involving nucleic acids
    • C12Q1/6806—Preparing nucleic acids for analysis, e.g. for polymerase chain reaction [PCR] assay
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12Q—MEASURING OR TESTING PROCESSES INVOLVING ENZYMES, NUCLEIC ACIDS OR MICROORGANISMS; COMPOSITIONS OR TEST PAPERS THEREFOR; PROCESSES OF PREPARING SUCH COMPOSITIONS; CONDITION-RESPONSIVE CONTROL IN MICROBIOLOGICAL OR ENZYMOLOGICAL PROCESSES
    • C12Q1/00—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions
    • C12Q1/68—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions involving nucleic acids
    • C12Q1/6844—Nucleic acid amplification reactions
    • C12Q1/6858—Allele-specific amplification
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12Q—MEASURING OR TESTING PROCESSES INVOLVING ENZYMES, NUCLEIC ACIDS OR MICROORGANISMS; COMPOSITIONS OR TEST PAPERS THEREFOR; PROCESSES OF PREPARING SUCH COMPOSITIONS; CONDITION-RESPONSIVE CONTROL IN MICROBIOLOGICAL OR ENZYMOLOGICAL PROCESSES
    • C12Q1/00—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions
    • C12Q1/68—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions involving nucleic acids
    • C12Q1/6844—Nucleic acid amplification reactions
    • C12Q1/686—Polymerase chain reaction [PCR]
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12Q—MEASURING OR TESTING PROCESSES INVOLVING ENZYMES, NUCLEIC ACIDS OR MICROORGANISMS; COMPOSITIONS OR TEST PAPERS THEREFOR; PROCESSES OF PREPARING SUCH COMPOSITIONS; CONDITION-RESPONSIVE CONTROL IN MICROBIOLOGICAL OR ENZYMOLOGICAL PROCESSES
    • C12Q1/00—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions
    • C12Q1/68—Measuring or testing processes involving enzymes, nucleic acids or microorganisms; Compositions therefor; Processes of preparing such compositions involving nucleic acids
    • C12Q1/6876—Nucleic acid products used in the analysis of nucleic acids, e.g. primers or probes
    • C12Q1/6883—Nucleic acid products used in the analysis of nucleic acids, e.g. primers or probes for diseases caused by alterations of genetic material
    • C12Q1/6886—Nucleic acid products used in the analysis of nucleic acids, e.g. primers or probes for diseases caused by alterations of genetic material for cancer
    • C—CHEMISTRY; METALLURGY
    • C40—COMBINATORIAL TECHNOLOGY
    • C40B—COMBINATORIAL CHEMISTRY; LIBRARIES, e.g. CHEMICAL LIBRARIES
    • C40B40/00—Libraries per se, e.g. arrays, mixtures
    • C40B40/04—Libraries containing only organic compounds
    • C40B40/06—Libraries containing nucleotides or polynucleotides, or derivatives thereof
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12N—MICROORGANISMS OR ENZYMES; COMPOSITIONS THEREOF; PROPAGATING, PRESERVING, OR MAINTAINING MICROORGANISMS; MUTATION OR GENETIC ENGINEERING; CULTURE MEDIA
    • C12N2320/00—Applications; Uses
    • C12N2320/10—Applications; Uses in screening processes
    • C—CHEMISTRY; METALLURGY
    • C12—BIOCHEMISTRY; BEER; SPIRITS; WINE; VINEGAR; MICROBIOLOGY; ENZYMOLOGY; MUTATION OR GENETIC ENGINEERING
    • C12Q—MEASURING OR TESTING PROCESSES INVOLVING ENZYMES, NUCLEIC ACIDS OR MICROORGANISMS; COMPOSITIONS OR TEST PAPERS THEREFOR; PROCESSES OF PREPARING SUCH COMPOSITIONS; CONDITION-RESPONSIVE CONTROL IN MICROBIOLOGICAL OR ENZYMOLOGICAL PROCESSES
    • C12Q2600/00—Oligonucleotides characterized by their use
    • C12Q2600/156—Polymorphic or mutational markers

Landscapes

  • Chemical & Material Sciences (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Health & Medical Sciences (AREA)
  • Organic Chemistry (AREA)
  • Engineering & Computer Science (AREA)
  • Genetics & Genomics (AREA)
  • Zoology (AREA)
  • Wood Science & Technology (AREA)
  • Biotechnology (AREA)
  • General Engineering & Computer Science (AREA)
  • Bioinformatics & Cheminformatics (AREA)
  • Molecular Biology (AREA)
  • Biochemistry (AREA)
  • Proteomics, Peptides & Aminoacids (AREA)
  • Microbiology (AREA)
  • Biomedical Technology (AREA)
  • Biophysics (AREA)
  • Physics & Mathematics (AREA)
  • General Health & Medical Sciences (AREA)
  • Chemical Kinetics & Catalysis (AREA)
  • Analytical Chemistry (AREA)
  • Immunology (AREA)
  • Plant Pathology (AREA)
  • Crystallography & Structural Chemistry (AREA)
  • Bioinformatics & Computational Biology (AREA)
  • General Chemical & Material Sciences (AREA)
  • Medicinal Chemistry (AREA)
  • Pathology (AREA)
  • Hospice & Palliative Care (AREA)
  • Oncology (AREA)
  • Medicines That Contain Protein Lipid Enzymes And Other Medicines (AREA)
  • Measuring Or Testing Involving Enzymes Or Micro-Organisms (AREA)

Abstract

本发明公开了一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，属于生物技术领域。该方法可检测包括手术切除的新鲜病理组织，甲醛固定石蜡包埋病例组织，石蜡切片，全血，血浆，血清，胸腔积液等标本中子宫内膜癌相关基因MSH2、PMS2、MLH1、MSH6、EPCAM、TP53、POLE、PTEN的突变类型，可针对多个靶序列进行单管，快速完成文库的构建，整个文库构建过程仅需要3小时，手动时间仅仅需要30分钟即可，结合高通量测序平台可以十分有效的解决目前对于临床上子宫内膜癌样本中在少量的临床样本基础上需要对体细胞多基因全外显子突变检测这一难点，且成本低廉。

Description

一种基于高通量测序检测子宫内膜癌相关基因突变的文库构 建方法
技术领域
本发明属于生物技术领域，尤其涉及一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法。
背景技术
子宫内膜癌是发生于子宫内膜的一组上皮性恶性子宫内膜癌，好发于围绝经期和绝经后女性。子宫内膜癌是最常见的女性生殖***子宫内膜癌之一，每年有接近20万的新发病例，并是导致死亡的第三位常见妇科恶性子宫内膜癌(仅次于卵巢癌和***)。
尽管大多数子宫内膜癌不在家族中发生，但约3％的子宫内膜癌是遗传的。其中，林奇综合征是最常见的病因。与没有这种疾病的人相比，患有林奇综合征的人更容易患子宫内膜癌、结直肠癌和其他癌症。如果一个子宫内膜癌的妇女被发现患有林奇综合征，她患结直肠癌的几率就会高得多。因为林奇综合征是遗传性的，这个信息对家庭成员很重要，因此对于子宫内膜癌患者进行检测是否患有林奇综合征尤其重要。
林奇综合征是一种高度渗透性，常染色体显性遗传易感综合征，其由错配修复基因(特别是MLH1，MSH2，MSH6或PMS2)中的单等位基因种系突变引起，或者由EPCAM中的种系缺失导致相邻MSH2基因的表观遗传沉默所致。大约2–6％的内膜癌属于Lynch综合征；TP53是人类癌症中最常见的突变基因，种系突变发生在癌症易感Li-Fraumeni综合症；Cowden综合征是PTEN种系突变引起的一种疾病，突变携带者的子宫内膜癌易感性增加。子宫内膜癌的POLE突变，导致校正不足的患者已显示出更好的预后。
目前常用的检测子宫内膜癌相关基因MSH2、PMS2、MLH1、MSH6、EPCAM、TP53、POLE、PTEN的方法是使用Sanger测序法，通过设计这些基因的引物进行分管分段测得基因序列，进行分析是否存在突变，由于这8个基因基因序列比较长，通过Sanger测序法进行检测时需要至少200以上个扩增管进行单独扩增后测序，这样导致对样本的量需求大、操作人员工作量大、完成检测时间长和每个样本测序成本高。因此，亟需一种不但高效而且可同时检测上述八种基因的方法。
发明内容
为了解决上述技术问题，本发明提供一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法。
本发明提供的文库构建方法用于定性检测子宫内膜癌(Endometrial Cancer,EC)患者石蜡组织切片样本中MSH2、PMS2、MLH1、MSH6、EPCAM、TP53、POLE、PTEN八个相关基因的突变状态，检测范围涵盖这八个基因的编码区和外显子内含子连接区，分析内膜癌的分子特征以评估家族遗传风险、预测疾病的复发和指导药物治疗。而且该方法仅需要10ng的DNA样本量，在单管完成文库的构建，操作简单方便，仅需3.5个小时完成文库构建，极大的降低了检测成本。
为达上述目的，本发明采用如下的技术方案：
一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，包括如下步骤：
1.根据子宫内膜癌相关8个基因(MSH2、PMS2、MLH1、MSH6、EPCAM、TP53、POLE、PTEN)全外显子的野生型基因序列，设计多对特异修饰性简并引物。引物设计要充分考虑到超多重PCR反应中，引物间的交联导致的非特异性，以及每对引物扩增效率不同导致的均一性差别，因此本发明的引物设计与常规的PCR反应的引物完全不同，难度更大。
本发明设计的子宫内膜癌8个相关基因的引物序列SEQ ID NO.1-759如表1所示。
表1子宫内膜癌8个相关基因的检测引物
Figure BDA0002711995800000021
Figure BDA0002711995800000031
Figure BDA0002711995800000041
Figure BDA0002711995800000051
Figure BDA0002711995800000061
Figure BDA0002711995800000071
Figure BDA0002711995800000081
Figure BDA0002711995800000091
Figure BDA0002711995800000101
Figure BDA0002711995800000111
Figure BDA0002711995800000121
Figure BDA0002711995800000131
Figure BDA0002711995800000141
Figure BDA0002711995800000151
Figure BDA0002711995800000161
Figure BDA0002711995800000171
Figure BDA0002711995800000181
2.待测样品处理和模板提取
样品适用范围包括手术切除的新鲜病理组织，甲醛固定石蜡包埋病例组织，石蜡切片，全血，血浆，血清，胸腔积液等标本。
蜡块样品切成5～8μm切片，取5片，或已经制成的5～8μm切片取5片，经过二甲苯脱蜡后，使用美基公司石蜡包埋DNA提取试剂盒提取基因组DNA，具体步骤按试剂盒操作说明。
全血、血浆、血清以及胸腔积液样品，使用Qiagen公司组织DNA提取试剂盒提取基因组DNA，具体步骤按试剂盒操作说明。每次提取全血200μl，血浆、血清以及胸腔积液不少于800μl。
所提DNA溶于Tris-HCl(10mmol/L,pH 8.0)，经紫外分光光度计检测提取质量，并确定浓度，用Tris-HCl溶液(10mmol/L,pH 8.0)调整DNA浓度到2ng/μl作为PCR扩增的模板。
3.超多重PCR反应体系的配制及PCR扩增
配制超多重PCR扩增连接基因序列的反应体系，本反应体系不仅要考虑到扩增反应的扩增效率，同时要考虑每对引物的扩增的效率和特异性扩增。
(1)每人份DNA富集反应引物MIX按照表2进行配制。
表2 DNA富集反应引物MIX
Figure BDA0002711995800000191
Figure BDA0002711995800000201
Figure BDA0002711995800000211
Figure BDA0002711995800000221
Figure BDA0002711995800000231
Figure BDA0002711995800000241
Figure BDA0002711995800000251
Figure BDA0002711995800000261
Figure BDA0002711995800000271
Figure BDA0002711995800000281
Figure BDA0002711995800000291
Figure BDA0002711995800000301
Figure BDA0002711995800000311
Figure BDA0002711995800000321
Figure BDA0002711995800000331
(2)每人份DNAPCR反应体系配方如表3所示。
表3 DNA PCR反应体系的配方
Figure BDA0002711995800000332
Figure BDA0002711995800000341
其中Ion-BCXX-F和Ion-BCXX-R表示不对称连接探针组包括Ion-BC1-F、Ion-BC1-R、Ion-BC2-F、Ion-BC2-R、Ion-BC3-F、Ion-BC3-R、Ion-BC4-F、Ion-BC4-R、Ion-BC5-F、Ion-BC5-R、Ion-BC6-F、Ion-BC6-R、Ion-BC7-F、Ion-BC7-R、Ion-BC8-F和Ion-BC8-R，上述BC1～8分别表示八种不同的标签序列，每种探针的浓度都是50μM，C-Primer为不与人类基因组形成互补的通用引物。
(3)步骤(2)中配制的反应体系按照表4所示的扩增程序进行PCR扩增。
表4 PCR扩增程序
Figure BDA0002711995800000342
4.将上述扩增产物通过磁珠纯化、毛细管电泳，获得扩增片段主要产物大小为180bp即可得到样本的文库，将文库用于下一步高通量测序仪器进行检测，得到目标序列信息，通过与野生型序列信息进行比对，即可判断突变状态。
所述一种检测基于高通量测序平台检测人类子宫内膜癌8个相关基因全外显子基因突变的文库构建方法不包括对待测样品处理和模板提取步骤，对于来自甲醛固定石蜡包埋的样品的短片段DNA依然具有与新鲜组织样品和血液样品DNA同样的扩增和检测能力。
与现有技术相比，本发明具有如下有益效果：
(1)本发明的单管高通量测序文库的构建方法针对多个靶序列进行单管，快速完成文库的构建，整个文库构建过程仅需要3小时，手动时间仅仅需要30分钟即可，结合高通量测序平台可以十分有效的解决目前对于临床上子宫内膜癌样本中在少量的临床样本基础上需要对体细胞多基因全外显子突变检测这一难点，且成本低廉；
(2)本发明的构建方法所制备的文库序列可被目前高通量测序***识别并进行检测，从而实现文库构建进行核酸序列的检测的应用，该核酸检测可应用于目前多种高通量测序平台。
附图说明
图1为实施例1中核酸文库片段大小数据图。
图2为实施例1中多重链接扩增PCR检测子宫内膜癌8个相关基因单样本下机数据量统计图。
图3为实施例1中多重链接扩增PCR检测子宫内膜癌8个相关基因突变检测均一性图。
图4为实施例1中多重链接扩增PCR检测子宫内膜癌8个相关基因突变的检测突变结果。
图5为实施例1中PTEN基因c.397G>A突变(COSM5044)检测比对结果示意图。
具体实施方式
以下实施例中使用的MgCl2，dNTP购自中国大连宝生物公司。RingCap buffer和RingCap-Taq酶由厦门飞朔生物技术有限公司自行生产。
实施例1
本例收集临床子宫内膜癌样本100例，同时进行传统的Sanger测序法和本发明方法进行双盲比较。本实施例中入组100例临床子宫内膜癌样本均来自医院的捐赠，经病理诊断为子宫内膜癌的样本，同时考虑有家族遗传性的，样本经过石蜡包埋后切取5微米的7片白片作为对比样本。
利用上述方法包括以下步骤：
(1)样品处理和模板提取质控
蜡块样品切成5～8μm切片，取5片，或已经制成的5～8μm切片取5片，经过二甲苯脱蜡后，使用美基公司石蜡包埋DNA提取试剂盒提取基因组DNA，具体步骤按试剂盒操作说明。所提DNA溶于Tris-HCl(10mmol/L,pH 8.0)，经紫外分光光度计检测提取质量，并确定浓度，用Tris-HCl溶液(10mmol/L,pH 8.0)调整DNA浓度到100ng/μl或2ng/μl作为PCR扩增的模板。
(2)超多重PCR扩增反应体系及PCR扩增
其中DNA富集反应引物是上述表1中引物序列SEQ ID NO.1-742，合成后稀释至50μM，并按照表2比例进行混合，从中取5μL。按照上述表3配制多重PCR扩增反应体系，后按照表4扩增程序进行多重PCR扩增。
(3)文库纯化方法
第一轮纯化步骤：
①向每个样品反应管25μL产物中分别加入12.5μL(0.5x样本体积)的AgencourtAMPure XP试剂，上下吸取吹打5次，完全混匀重悬DNA；
②室温孵育5分钟；
③放置在磁力架上面，孵育5分钟，一直到溶液澄清；
④小心地吸取上清液置于新的离心管，不要扰动磁珠；注意：上清液中含有扩增文库不要丢弃。
第二轮纯化步骤：
①向上述吸取的上清液25μL中加入30μL(1.2x样本体积)的Agencourt AMPure XP试剂，上下吸取吹打5次，完全混匀重悬DNA；
②室温孵育5分钟；
③放置在磁力架上面，孵育3分钟，一直到溶液澄清，小心地吸走并弃掉上清，不要扰动磁珠；注意：磁珠上含有扩增文库不要丢弃。
④加入150μl新鲜配制的70％乙醇，没过磁珠样品即可，离心管正反方向移动5次，然后磁力架上孵育2分钟，去除上清液；
⑤重复上述步骤4，进行第二次洗涤；
⑥确保乙醇液滴已全部从孔中吸走，将板放置于磁力架上，室温空气干燥5分钟，注意不要过度干燥。
⑦将样品管从磁力架上拿开，在每孔中加入25μL TE(PH8.0)缓冲液充分浸润磁珠。充分振荡混匀，快速离心将液体收集到管底。(也可以选择用枪吸取一半以上的液体上下吹打至少5次来混匀)；注意：上清液含有扩增文库不要丢弃。
⑧将样品管置于磁力架上2分钟。上清液中含有扩增文库。取出20μL上清。
⑨所得文库进行毛细管电泳片段检测，图1为文库电泳检测的结果，文库的主峰280-300之间。
(4)上机检测：采用Miseq测序仪(illumina公司)一次可以检测30份样品，其中包括阳性对照：突变型细胞系DNA；阴性对照：野生型细胞系DNA。
测序下机数据进行序列的比对分析。图2为本发明多重链接扩增PCR检测子宫内膜癌8个相关基因单样本下机数据量统计图，图中所示扩增子序列占比达92.52％，表示我们测序所得的reads中能比对我们靶标序列的reads有92.52％，说明本发明所用多重引物的扩增特异性高。图2所示扩增子均一性为91.04％，该数值越高说明不同扩增子的测序深度接近。图3柱状图的每个柱表示一个扩增子，柱的高度表示对应扩增子测序的测序深度，图中可以直观地看出不同扩增子的测序深度较一致，说明本发明多重引物的扩增均一性良好。图4为一份阳性临床样本测序比对后注释的结果，结果显示该样本PTEN基因存在c.397G>A突变(COSM5044)，COSMIC数据库记录为致病性突变。图5为IGV比对可视化软件查看c.397G>A突变的结果。
对于100个子宫内膜癌临床样本，本发明检测结果与Sanger测序结果完全一致：100例样品中有6例发生TP53基因突变，4例发生POLE基因突变，2例发生MSH2基因突变，3例发生EPCAM基因突变，其余85例均为野生型，具体如表5所示。
表5高通量测序检测结果与Sanger测序结果的比较
Figure BDA0002711995800000371
实施例2
本实施例在于考察本发明方法的灵敏度和特异性，选用下表6已知常见突变位点作为阳性质粒构建的序列。
表6阳性质粒
编号 基因名称 突变COSMIC号 碱基变化 突变类型
M1 TP53 COSM44957 c.80del 缺失突变
M2 POLE COSM937332 c.857C>G 点突变
M3 PTEN COSM1684696 c.38_39insC ***突变
M4 EPCAM COSM4681226 c.924G>A 点突变
M5 MSH6 COSM190062 c.1082G>A 点突变
M6 MLH1 COSM6943688 c.105_107del 缺失突变
M7 PMS2 COSM5621554 c.209A>G 点突变
M8 MSH2 COSM5751788 c.89_90insT ***突变
通过基因工程技术合成上述突变序列质粒，长度均为500bp。
1.样品处理：同时收集临床癌旁组织10例，经过Sanger测序验证为该8个基因阴性样本，分别命名为WT1～10。将野生型的DNA稀释至2ng/μL，同时将上述8个质粒稀释至104/μL，用2ng/μL野生型DNA作为稀释液，依次将上述8个质粒稀释至103/μL，102/μL，101/μL，100/μL。共计32个质粒样本和10份野生型DNA。
2.超多重PCR扩增反应以及文库纯化步骤与实施例1相同。
3.上机检测：采用Miseq测序仪(illumina公司)一次可以检测30份样品(包括阴阳性对照)，结果如表7所示，10份野生型样本的检测结果均为阴性，没有检测到致病性突变。8个阳性质粒梯度稀释的检测结果也表明，本发明具有较高的检测灵敏度，至少能达到101拷贝/μL，其中M4和M6检测灵敏度达到100拷贝/μL。
表7检测结果
Figure BDA0002711995800000381
实施例3
本实施例通过临床样本检测考察本发明方法的重复性。
收集临床子宫内膜癌样本10例，同时进行传统的Sanger测序法进行检测，突变结果如表8所示。
表8 Sanger测序结果
Figure BDA0002711995800000382
Figure BDA0002711995800000391
利用上述方法包括以下步骤：
1.样品处理和模板提取质控：将临床收集到的蜡块样品切成5～8μm切片，取5片，或已经制成的5～8μm切片取5片，经过二甲苯脱蜡后，使用美基公司石蜡包埋DNA提取试剂盒提取基因组DNA，具体步骤按试剂盒操作说明。所提DNA溶于Tris-HCl(10mmol/L,pH8.0)，经紫外分光光度计检测提取质量，并确定浓度，用Tris-HCl溶液(10mmol/L,pH 8.0)调整DNA浓度到100ng/μl或2ng/μl作为PCR扩增的模板。每个样本做7次重复。
2.超多重PCR扩增反应以及文库纯化步骤与实施例1相同。
3.上机检测：采用Miseq测序仪(illumina公司)一次可以检测30份样品(包括阴阳性对照)，检测结果如表9所示。
表9重复性检测结果
Figure BDA0002711995800000392
从上述结果可以看出本发明提供的文库构建方法对来自临床真实样本的检测重复性效果很好。
本发明子宫内膜癌多基因文库构建方法可同时检测8个子宫内膜癌基因全外显子突变位点，文库构建时间仅需3小时，因此本发明省时省力，准确性高，可满足突变的快速诊断。而且，高通量测序法和传统测序方法结果的符合率为100％，高通量测序法灵敏度和选择性检测能力高于传统测序方法，10ng样品DNA中含1％的突变DNA即可检出。
以上所述的实施例仅是对本发明的优选方式进行描述，并非对本发明的范围进行限定，在不脱离本发明设计精神的前提下，本领域普通技术人员对本发明的技术方案做出的各种变形和改进，均应落入本发明权利要求书确定的保护范围内。
序列表
<110> 厦门飞朔生物技术有限公司
<120> 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法
<130> 2020.9.14
<141> 2020-09-30
<160> 759
<170> SIPOSequenceListing 1.0
<210> 1
<211> 35
<212> DNA
<213> 人工序列()
<400> 1
ttttttttat cacttttaaa tgggtgtgat gtgta 35
<210> 2
<211> 26
<212> DNA
<213> 人工序列()
<400> 2
ttttttttga cacatcgcca acctgg 26
<210> 3
<211> 33
<212> DNA
<213> 人工序列()
<400> 3
ttttttttag ttgagagtct gaggtctgaa aaa 33
<210> 4
<211> 33
<212> DNA
<213> 人工序列()
<400> 4
tttttttttc aggaagtttt gtgacactta gct 33
<210> 5
<211> 34
<212> DNA
<213> 人工序列()
<400> 5
tttttttttt taaagtagat acaaggtctt gctg 34
<210> 6
<211> 25
<212> DNA
<213> 人工序列()
<400> 6
ttttttttag cagcacaccg tgctc 25
<210> 7
<211> 34
<212> DNA
<213> 人工序列()
<400> 7
ttttttttaa atcccaggtt aaactgacca atga 34
<210> 8
<211> 32
<212> DNA
<213> 人工序列()
<400> 8
ttttttttgg atggctaggg actttatttt gt 32
<210> 9
<211> 36
<212> DNA
<213> 人工序列()
<400> 9
ttttttttaa ctttacctta tctcttttct tagttc 36
<210> 10
<211> 27
<212> DNA
<213> 人工序列()
<400> 10
ttttttttaa agttgtgccc ctggact 27
<210> 11
<211> 28
<212> DNA
<213> 人工序列()
<400> 11
tttttttttt ccccttcact ttgctgtg 28
<210> 12
<211> 31
<212> DNA
<213> 人工序列()
<400> 12
tttttttttc tttccagttc tgacatttgt c 31
<210> 13
<211> 30
<212> DNA
<213> 人工序列()
<400> 13
ttttttttca tcaacctgag aggctgacat 30
<210> 14
<211> 28
<212> DNA
<213> 人工序列()
<400> 14
ttttttttgt ggactgccat tcaaacca 28
<210> 15
<211> 28
<212> DNA
<213> 人工序列()
<400> 15
ttttttttgt tggctgaggc aaaactcg 28
<210> 16
<211> 26
<212> DNA
<213> 人工序列()
<400> 16
ttttttttgc agtcactgca gcagcg 26
<210> 17
<211> 25
<212> DNA
<213> 人工序列()
<400> 17
ttttttttgg gagctggccg catac 25
<210> 18
<211> 29
<212> DNA
<213> 人工序列()
<400> 18
ttttttttgc gtcctgagac ctcagaaag 29
<210> 19
<211> 25
<212> DNA
<213> 人工序列()
<400> 19
ttttttttag ggtcactggg tccgt 25
<210> 20
<211> 28
<212> DNA
<213> 人工序列()
<400> 20
ttttttttgc ctcacagccc aaagactc 28
<210> 21
<211> 29
<212> DNA
<213> 人工序列()
<400> 21
ttttttttac cccttttctg tcctagagg 29
<210> 22
<211> 29
<212> DNA
<213> 人工序列()
<400> 22
ttttttttgc ccatggtaga aaagcagga 29
<210> 23
<211> 25
<212> DNA
<213> 人工序列()
<400> 23
ttttttttaa ggcctctcgc agtct 25
<210> 24
<211> 31
<212> DNA
<213> 人工序列()
<400> 24
ttttttttcc atttcaggat agtccctgac c 31
<210> 25
<211> 32
<212> DNA
<213> 人工序列()
<400> 25
ttttttttag gaaacacatt agctaaaagc tt 32
<210> 26
<211> 32
<212> DNA
<213> 人工序列()
<400> 26
ttttttttga ggaaaagctt ttgttggcag tt 32
<210> 27
<211> 32
<212> DNA
<213> 人工序列()
<400> 27
ttttttttgc ttgttgacat cactatcaaa ca 32
<210> 28
<211> 33
<212> DNA
<213> 人工序列()
<400> 28
ttttttttgc cttagaatgc gttgatatca atg 33
<210> 29
<211> 34
<212> DNA
<213> 人工序列()
<400> 29
tttttttttt ttcctcttgt agcaaaattt gcct 34
<210> 30
<211> 34
<212> DNA
<213> 人工序列()
<400> 30
ttttttttag agtgagacgc tgtctgaaaa taat 34
<210> 31
<211> 31
<212> DNA
<213> 人工序列()
<400> 31
tttttttttc tcattccagt catagcagag c 31
<210> 32
<211> 29
<212> DNA
<213> 人工序列()
<400> 32
tttttttttc tgcagactcg tgaatgagg 29
<210> 33
<211> 32
<212> DNA
<213> 人工序列()
<400> 33
tttttttttg gatactggtg tcgattatac at 32
<210> 34
<211> 32
<212> DNA
<213> 人工序列()
<400> 34
ttttttttct aagaacatgc tggttggtta ga 32
<210> 35
<211> 34
<212> DNA
<213> 人工序列()
<400> 35
ttttttttgc acaaaataag ataatgttaa agcc 34
<210> 36
<211> 27
<212> DNA
<213> 人工序列()
<400> 36
tttttttttt tatcaaccgg cggcctt 27
<210> 37
<211> 31
<212> DNA
<213> 人工序列()
<400> 37
ttttttttgt caaaggcata aagaacaaac t 31
<210> 38
<211> 33
<212> DNA
<213> 人工序列()
<400> 38
tttttttttc ctgcccttac catattaatg ttg 33
<210> 39
<211> 33
<212> DNA
<213> 人工序列()
<400> 39
ttttttttaa agaaaaactg tctgtctgtt gaa 33
<210> 40
<211> 33
<212> DNA
<213> 人工序列()
<400> 40
ttttttttca cctggtgttt tgttttcatt tca 33
<210> 41
<211> 32
<212> DNA
<213> 人工序列()
<400> 41
ttttttttac acgaaactat tagccttaga at 32
<210> 42
<211> 30
<212> DNA
<213> 人工序列()
<400> 42
ttttttttcc tagtgactcc gtgtgtgaag 30
<210> 43
<211> 33
<212> DNA
<213> 人工序列()
<400> 43
tttttttttc tcttgccagc aatctactta cta 33
<210> 44
<211> 32
<212> DNA
<213> 人工序列()
<400> 44
ttttttttgt ccactctgtc tttattagga ag 32
<210> 45
<211> 31
<212> DNA
<213> 人工序列()
<400> 45
ttttttttga caatggaaac ccgctataat c 31
<210> 46
<211> 31
<212> DNA
<213> 人工序列()
<400> 46
ttttttttgt gtaagttgca ccaatcagct t 31
<210> 47
<211> 29
<212> DNA
<213> 人工序列()
<400> 47
ttttttttca aacacagagc cgatatttt 29
<210> 48
<211> 33
<212> DNA
<213> 人工序列()
<400> 48
tttttttttt ttaaacagga gtatgccaaa atg 33
<210> 49
<211> 29
<212> DNA
<213> 人工序列()
<400> 49
ttttttttca cggatgcctg ctgaaatga 29
<210> 50
<211> 32
<212> DNA
<213> 人工序列()
<400> 50
ttttttttcc ttgatttgtg cgatgatgtg ag 32
<210> 51
<211> 28
<212> DNA
<213> 人工序列()
<400> 51
ttttttttcc ttatggcgca caggtagt 28
<210> 52
<211> 26
<212> DNA
<213> 人工序列()
<400> 52
ttttttttgc atcggcgaag gttgga 26
<210> 53
<211> 34
<212> DNA
<213> 人工序列()
<400> 53
ttttttttgg gttttctgga taattttccc attg 34
<210> 54
<211> 27
<212> DNA
<213> 人工序列()
<400> 54
ttttttttag tgcccaacat catgggt 27
<210> 55
<211> 33
<212> DNA
<213> 人工序列()
<400> 55
ttttttttaa gttgagatgt tgagatagaa aac 33
<210> 56
<211> 28
<212> DNA
<213> 人工序列()
<400> 56
tttttttttt gccgacctaa ctcaggtt 28
<210> 57
<211> 31
<212> DNA
<213> 人工序列()
<400> 57
tttttttttg tatcacctca gtgcacaaag t 31
<210> 58
<211> 35
<212> DNA
<213> 人工序列()
<400> 58
tttttttttc atgtatattt tgttgttata gcact 35
<210> 59
<211> 32
<212> DNA
<213> 人工序列()
<400> 59
tttttttttg tttttgcatt tcccaagaca gt 32
<210> 60
<211> 34
<212> DNA
<213> 人工序列()
<400> 60
ttttttttag cttaaggact atggagtgga tctt 34
<210> 61
<211> 35
<212> DNA
<213> 人工序列()
<400> 61
ttttttttag gattagaaaa agtcaactta cttaa 35
<210> 62
<211> 31
<212> DNA
<213> 人工序列()
<400> 62
ttttttttaa aaactgatag catgggtccg t 31
<210> 63
<211> 36
<212> DNA
<213> 人工序列()
<400> 63
tttttttttc aataacaaat gtttcttaac tacaac 36
<210> 64
<211> 27
<212> DNA
<213> 人工序列()
<400> 64
ttttttttca gatttgctct gggcagg 27
<210> 65
<211> 27
<212> DNA
<213> 人工序列()
<400> 65
ttttttttag actcagtacc acctgcc 27
<210> 66
<211> 34
<212> DNA
<213> 人工序列()
<400> 66
tttttttttt atttacagtg ttgagtcatt tccc 34
<210> 67
<211> 28
<212> DNA
<213> 人工序列()
<400> 67
tttttttttg gaatgccgtg ggtctcaa 28
<210> 68
<211> 29
<212> DNA
<213> 人工序列()
<400> 68
ttttttttct ggagggaact ttcccagtc 29
<210> 69
<211> 32
<212> DNA
<213> 人工序列()
<400> 69
ttttttttct attgcaagca agggttcaaa ga 32
<210> 70
<211> 31
<212> DNA
<213> 人工序列()
<400> 70
tttttttttc agtctacctc ccgccataaa a 31
<210> 71
<211> 32
<212> DNA
<213> 人工序列()
<400> 71
ttttttttgg gaacaagaag tggagaatgt ca 32
<210> 72
<211> 34
<212> DNA
<213> 人工序列()
<400> 72
tttttttttc tcactcatgt gatgtcatct ctcc 34
<210> 73
<211> 32
<212> DNA
<213> 人工序列()
<400> 73
ttttttttag actgaccctt tttggacttc ag 32
<210> 74
<211> 32
<212> DNA
<213> 人工序列()
<400> 74
ttttttttgg ccaccatctt gatttgaatt cc 32
<210> 75
<211> 33
<212> DNA
<213> 人工序列()
<400> 75
ttttttttat gaaggcagga tgagaatgga atc 33
<210> 76
<211> 31
<212> DNA
<213> 人工序列()
<400> 76
tttttttttc gagatgttcc gagagctgaa t 31
<210> 77
<211> 26
<212> DNA
<213> 人工序列()
<400> 77
ttttttttgc ctgggcatcc ttgagt 26
<210> 78
<211> 34
<212> DNA
<213> 人工序列()
<400> 78
tttttttttg ttgcttttgt accgtcataa agtc 34
<210> 79
<211> 32
<212> DNA
<213> 人工序列()
<400> 79
ttttttttct aggctaagct atgatgttcc tt 32
<210> 80
<211> 32
<212> DNA
<213> 人工序列()
<400> 80
ttttttttag agcatgaaaa tggttctatg ac 32
<210> 81
<211> 33
<212> DNA
<213> 人工序列()
<400> 81
ttttttttcg acgagtttat caggaagtaa cac 33
<210> 82
<211> 30
<212> DNA
<213> 人工序列()
<400> 82
tttttttttg gttgtagcta actaacttca 30
<210> 83
<211> 30
<212> DNA
<213> 人工序列()
<400> 83
ttttttttgc attttgagtg ttagactgga 30
<210> 84
<211> 32
<212> DNA
<213> 人工序列()
<400> 84
ttttttttcc tcagattcac ttttatcacc tt 32
<210> 85
<211> 30
<212> DNA
<213> 人工序列()
<400> 85
ttttttttag ggtgaaatat tctccatcca 30
<210> 86
<211> 30
<212> DNA
<213> 人工序列()
<400> 86
ttttttttag cactaagcga ggtaagcaag 30
<210> 87
<211> 29
<212> DNA
<213> 人工序列()
<400> 87
tttttttttc tgaggcataa ctgcaccct 29
<210> 88
<211> 29
<212> DNA
<213> 人工序列()
<400> 88
ttttttttac agctttgagg tgcgtgttt 29
<210> 89
<211> 30
<212> DNA
<213> 人工序列()
<400> 89
ttttttttcc ctttcttgcg gagattctct 30
<210> 90
<211> 32
<212> DNA
<213> 人工序列()
<400> 90
tttttttttt taaatgggac aggtaggacc tg 32
<210> 91
<211> 32
<212> DNA
<213> 人工序列()
<400> 91
ttttttttag aggtggatgg gtagtagtat gg 32
<210> 92
<211> 26
<212> DNA
<213> 人工序列()
<400> 92
tttttttttg catgggcggc atgaac 26
<210> 93
<211> 28
<212> DNA
<213> 人工序列()
<400> 93
ttttttttgc tcctgacctg gagtcttc 28
<210> 94
<211> 27
<212> DNA
<213> 人工序列()
<400> 94
ttttttttgc cacaggtctc cccaagg 27
<210> 95
<211> 30
<212> DNA
<213> 人工序列()
<400> 95
ttttttttcc actgacaacc acccttaacc 30
<210> 96
<211> 31
<212> DNA
<213> 人工序列()
<400> 96
ttttttttcc tcctcagcat cttatccgag t 31
<210> 97
<211> 32
<212> DNA
<213> 人工序列()
<400> 97
tttttttttc tgtcatccaa atactccaca cg 32
<210> 98
<211> 29
<212> DNA
<213> 人工序列()
<400> 98
ttttttttcc atgagcgctg ctcagatag 29
<210> 99
<211> 31
<212> DNA
<213> 人工序列()
<400> 99
ttttttttca gacctaagag caatcagtga g 31
<210> 100
<211> 29
<212> DNA
<213> 人工序列()
<400> 100
ttttttttca tggccatcta caagcagtc 29
<210> 101
<211> 29
<212> DNA
<213> 人工序列()
<400> 101
ttttttttcc tcacaacctc cgtcatgtg 29
<210> 102
<211> 32
<212> DNA
<213> 人工序列()
<400> 102
tttttttttg tctccttcct cttcctacag ta 32
<210> 103
<211> 30
<212> DNA
<213> 人工序列()
<400> 103
ttttttttgc cagttggcaa aacatcttgt 30
<210> 104
<211> 27
<212> DNA
<213> 人工序列()
<400> 104
ttttttttta gctcgctagt gggttgc 27
<210> 105
<211> 30
<212> DNA
<213> 人工序列()
<400> 105
ttttttttgg gtgaagagga atcccaaagt 30
<210> 106
<211> 30
<212> DNA
<213> 人工序列()
<400> 106
ttttttttag aaaacctacc agggcagcta 30
<210> 107
<211> 29
<212> DNA
<213> 人工序列()
<400> 107
tttttttttg tcccagaatg caagaagcc 29
<210> 108
<211> 30
<212> DNA
<213> 人工序列()
<400> 108
ttttttttag atgaagctcc cagaatgcca 30
<210> 109
<211> 25
<212> DNA
<213> 人工序列()
<400> 109
ttttttttcc gccggtgtag gagct 25
<210> 110
<211> 29
<212> DNA
<213> 人工序列()
<400> 110
ttttttttgc tcttttcacc catctacag 29
<210> 111
<211> 31
<212> DNA
<213> 人工序列()
<400> 111
ttttttttca gcatcaaatc atccattgct t 31
<210> 112
<211> 31
<212> DNA
<213> 人工序列()
<400> 112
tttttttttt cagacttcct gaaaacaacg t 31
<210> 113
<211> 27
<212> DNA
<213> 人工序列()
<400> 113
ttttttttgc ccaacccttg tccttac 27
<210> 114
<211> 32
<212> DNA
<213> 人工序列()
<400> 114
tttttttttc agacctatgg aaactgtgag tg 32
<210> 115
<211> 27
<212> DNA
<213> 人工序列()
<400> 115
ttttttttgc ctgcccttcc aatggat 27
<210> 116
<211> 29
<212> DNA
<213> 人工序列()
<400> 116
ttttttttag ggttggaagt gtctcatgc 29
<210> 117
<211> 30
<212> DNA
<213> 人工序列()
<400> 117
ttttttttgg cacttccgtt gagcatctag 30
<210> 118
<211> 35
<212> DNA
<213> 人工序列()
<400> 118
ttttttttcc gtaccagttc tcaatcatct ctttg 35
<210> 119
<211> 27
<212> DNA
<213> 人工序列()
<400> 119
ttttttttgg cgccaaaatg tcgttcg 27
<210> 120
<211> 31
<212> DNA
<213> 人工序列()
<400> 120
ttttttttcc gttaagtcgt agcccttaag t 31
<210> 121
<211> 35
<212> DNA
<213> 人工序列()
<400> 121
ttttttttaa cacgttaatg aggcactatt gtttg 35
<210> 122
<211> 32
<212> DNA
<213> 人工序列()
<400> 122
tttttttttt caggcctccc tctttaacaa tc 32
<210> 123
<211> 34
<212> DNA
<213> 人工序列()
<400> 123
tttttttttc tgtttgattt gccagtttag atgc 34
<210> 124
<211> 32
<212> DNA
<213> 人工序列()
<400> 124
ttttttttag agaaaggtcc tgactcttcc at 32
<210> 125
<211> 33
<212> DNA
<213> 人工序列()
<400> 125
tttttttttc aagaaaatgg gaattcaaag aga 33
<210> 126
<211> 33
<212> DNA
<213> 人工序列()
<400> 126
ttttttttca cctcgaaagc cataggtaga aat 33
<210> 127
<211> 33
<212> DNA
<213> 人工序列()
<400> 127
ttttttttaa aggttcacta ctagtaaact gca 33
<210> 128
<211> 34
<212> DNA
<213> 人工序列()
<400> 128
ttttttttca gacaatgtca tcacaggagg atat 34
<210> 129
<211> 32
<212> DNA
<213> 人工序列()
<400> 129
ttttttttgt tcagataacc tttccctttg gt 32
<210> 130
<211> 32
<212> DNA
<213> 人工序列()
<400> 130
ttttttttag tcagcactat acctgtatgc ac 32
<210> 131
<211> 32
<212> DNA
<213> 人工序列()
<400> 131
ttttttttat tttcttttct tccttaggct tt 32
<210> 132
<211> 31
<212> DNA
<213> 人工序列()
<400> 132
tttttttttg agacaggatt actctgagac c 31
<210> 133
<211> 33
<212> DNA
<213> 人工序列()
<400> 133
tttttttttt ctcttttccc cttgggatta gta 33
<210> 134
<211> 33
<212> DNA
<213> 人工序列()
<400> 134
tttttttttc aacaatttac tctcccatgt acc 33
<210> 135
<211> 31
<212> DNA
<213> 人工序列()
<400> 135
tttttttttc ctaaaccatg tgctggcaat c 31
<210> 136
<211> 31
<212> DNA
<213> 人工序列()
<400> 136
ttttttttgg gacctccatt aactagtgca a 31
<210> 137
<211> 32
<212> DNA
<213> 人工序列()
<400> 137
ttttttttgt gcttagaact gtgctgttgg ta 32
<210> 138
<211> 31
<212> DNA
<213> 人工序列()
<400> 138
ttttttttaa agcttttctc ctcgtggcta t 31
<210> 139
<211> 33
<212> DNA
<213> 人工序列()
<400> 139
ttttttttat caatcttctg ttcaggtgga gga 33
<210> 140
<211> 33
<212> DNA
<213> 人工序列()
<400> 140
tttttttttg agcactagaa cacattactt tga 33
<210> 141
<211> 34
<212> DNA
<213> 人工序列()
<400> 141
ttttttttga catctagtgt gtgtttttgg caac 34
<210> 142
<211> 35
<212> DNA
<213> 人工序列()
<400> 142
ttttttttca ccagcaaact attaaaaatc ccctt 35
<210> 143
<211> 33
<212> DNA
<213> 人工序列()
<400> 143
ttttttttgg ttatgatgtt tcagtctcag cca 33
<210> 144
<211> 33
<212> DNA
<213> 人工序列()
<400> 144
ttttttttag gttatcgaca taccgactaa cag 33
<210> 145
<211> 30
<212> DNA
<213> 人工序列()
<400> 145
ttttttttct caaccgtgga caatattcgc 30
<210> 146
<211> 31
<212> DNA
<213> 人工序列()
<400> 146
ttttttttcc tgtgtatttg actaaagcaa a 31
<210> 147
<211> 36
<212> DNA
<213> 人工序列()
<400> 147
ttttttttat gggaaggaac cttgtgtttt taaatt 36
<210> 148
<211> 32
<212> DNA
<213> 人工序列()
<400> 148
ttttttttca ctgagtagtt tgcattggat at 32
<210> 149
<211> 35
<212> DNA
<213> 人工序列()
<400> 149
ttttttttag aaattggatg tgaggataaa accct 35
<210> 150
<211> 32
<212> DNA
<213> 人工序列()
<400> 150
ttttttttat ggtcccataa aattccctgt gg 32
<210> 151
<211> 34
<212> DNA
<213> 人工序列()
<400> 151
tttttttttg tctttcctga ggtgatttca tgac 34
<210> 152
<211> 32
<212> DNA
<213> 人工序列()
<400> 152
tttttttttt tttgggcaaa taggctgcat ac 32
<210> 153
<211> 34
<212> DNA
<213> 人工序列()
<400> 153
ttttttttga tcgtctggta gaatcaactt cctt 34
<210> 154
<211> 34
<212> DNA
<213> 人工序列()
<400> 154
ttttttttat ctctttcaaa gaggagagcc tgat 34
<210> 155
<211> 34
<212> DNA
<213> 人工序列()
<400> 155
ttttttttca tacaccatat gtgggctttt tctc 34
<210> 156
<211> 32
<212> DNA
<213> 人工序列()
<400> 156
ttttttttgc aggaagtgaa cttcatgctt tg 32
<210> 157
<211> 32
<212> DNA
<213> 人工序列()
<400> 157
ttttttttca gtccccagaa tgtggatgtt aa 32
<210> 158
<211> 31
<212> DNA
<213> 人工序列()
<400> 158
ttttttttga gaagtagctg gatgagaagc g 31
<210> 159
<211> 33
<212> DNA
<213> 人工序列()
<400> 159
ttttttttcc aattcctcca ggatgtactt cac 33
<210> 160
<211> 36
<212> DNA
<213> 人工序列()
<400> 160
ttttttttat ccaggtaata cttgcaaaga aagttc 36
<210> 161
<211> 31
<212> DNA
<213> 人工序列()
<400> 161
ttttttttta cagactttgc taccaggact t 31
<210> 162
<211> 32
<212> DNA
<213> 人工序列()
<400> 162
ttttttttga aatgcatcaa gcttctgttc cc 32
<210> 163
<211> 35
<212> DNA
<213> 人工序列()
<400> 163
tttttttttt ctggaagtag tgataaggtc tatgc 35
<210> 164
<211> 32
<212> DNA
<213> 人工序列()
<400> 164
ttttttttcc tagccctgcc actagaaata tc 32
<210> 165
<211> 31
<212> DNA
<213> 人工序列()
<400> 165
ttttttttca ggccattgtc acagaggata a 31
<210> 166
<211> 33
<212> DNA
<213> 人工序列()
<400> 166
tttttttttt ctgaagtccc ctttgttgta tcc 33
<210> 167
<211> 32
<212> DNA
<213> 人工序列()
<400> 167
ttttttttag caagatgagg agatgcttga ac 32
<210> 168
<211> 32
<212> DNA
<213> 人工序列()
<400> 168
ttttttttag aataaaggag gtaggctgta ct 32
<210> 169
<211> 34
<212> DNA
<213> 人工序列()
<400> 169
ttttttttct tcagaaatgt cagagaagag agga 34
<210> 170
<211> 34
<212> DNA
<213> 人工序列()
<400> 170
ttttttttgc agagagaaga tgcaagtgat tcat 34
<210> 171
<211> 33
<212> DNA
<213> 人工序列()
<400> 171
ttttttttgt tcattcacag ctctgtagaa cca 33
<210> 172
<211> 33
<212> DNA
<213> 人工序列()
<400> 172
ttttttttca tcttccacca tttccacatc aga 33
<210> 173
<211> 35
<212> DNA
<213> 人工序列()
<400> 173
ttttttttat gatctgcact tccttttctt cattg 35
<210> 174
<211> 34
<212> DNA
<213> 人工序列()
<400> 174
ttttttttcc ctgctcatta atttcttcct ggag 34
<210> 175
<211> 33
<212> DNA
<213> 人工序列()
<400> 175
ttttttttgg aagatgattc ccgaaaggaa atg 33
<210> 176
<211> 32
<212> DNA
<213> 人工序列()
<400> 176
ttttttttat ttccaaaacc ttggcagttg ag 32
<210> 177
<211> 33
<212> DNA
<213> 人工序列()
<400> 177
ttttttttgg ttggtaggat tctattactt acc 33
<210> 178
<211> 32
<212> DNA
<213> 人工序列()
<400> 178
ttttttttgc tgatttacct aagcttggtg gt 32
<210> 179
<211> 30
<212> DNA
<213> 人工序列()
<400> 179
ttttttttgt tttgcagttc tccgggagat 30
<210> 180
<211> 32
<212> DNA
<213> 人工序列()
<400> 180
ttttttttct ccctggacca ttgttgtagt ag 32
<210> 181
<211> 34
<212> DNA
<213> 人工序列()
<400> 181
ttttttttct caagcatgaa ttcagctttt cctt 34
<210> 182
<211> 32
<212> DNA
<213> 人工序列()
<400> 182
ttttttttag ctactatttt cagaaacgat ca 32
<210> 183
<211> 29
<212> DNA
<213> 人工序列()
<400> 183
ttttttttgg atgctccgtt aaagcttgc 29
<210> 184
<211> 33
<212> DNA
<213> 人工序列()
<400> 184
ttttttttag ccttcttctt cagaaactca aca 33
<210> 185
<211> 32
<212> DNA
<213> 人工序列()
<400> 185
ttttttttcc caaagaagga cttgctgaat ac 32
<210> 186
<211> 32
<212> DNA
<213> 人工序列()
<400> 186
ttttttttcc cggctggaaa ttttatttga ag 32
<210> 187
<211> 34
<212> DNA
<213> 人工序列()
<400> 187
ttttttttag cactggagaa atgggatttg ttta 34
<210> 188
<211> 30
<212> DNA
<213> 人工序列()
<400> 188
ttttttttcc tcagtggcta gtcgaagaat 30
<210> 189
<211> 31
<212> DNA
<213> 人工序列()
<400> 189
ttttttttgg aacctgattg gattacccct t 31
<210> 190
<211> 31
<212> DNA
<213> 人工序列()
<400> 190
ttttttttat tccagatcaa agggtggtca t 31
<210> 191
<211> 33
<212> DNA
<213> 人工序列()
<400> 191
ttttttttgt ctgtgatctc cgtttagaat gag 33
<210> 192
<211> 32
<212> DNA
<213> 人工序列()
<400> 192
ttttttttag ggtcgactcc tcagatatgt ac 32
<210> 193
<211> 32
<212> DNA
<213> 人工序列()
<400> 193
ttttttttcc aggtgaattg ggacgaagaa aa 32
<210> 194
<211> 34
<212> DNA
<213> 人工序列()
<400> 194
ttttttttaa gattgtatga ggtcctgtcc tagt 34
<210> 195
<211> 34
<212> DNA
<213> 人工序列()
<400> 195
tttttttttt caaaagccct agataacacc aagt 34
<210> 196
<211> 32
<212> DNA
<213> 人工序列()
<400> 196
ttttttttac aatgtgttcc acagtccact tc 32
<210> 197
<211> 34
<212> DNA
<213> 人工序列()
<400> 197
ttttttttct aatgtgtttt ccagagtgaa gtgc 34
<210> 198
<211> 33
<212> DNA
<213> 人工序列()
<400> 198
ttttttttca aagactttgt atagatcagg cag 33
<210> 199
<211> 33
<212> DNA
<213> 人工序列()
<400> 199
ttttttttga tggaaatatc ctgcagcttg cta 33
<210> 200
<211> 33
<212> DNA
<213> 人工序列()
<400> 200
ttttttttat gttggtacac tttgtatatc aca 33
<210> 201
<211> 27
<212> DNA
<213> 人工序列()
<400> 201
ttttttttgg ctcctcgtgt cccactc 27
<210> 202
<211> 25
<212> DNA
<213> 人工序列()
<400> 202
ttttttttca atccgcgcct cacct 25
<210> 203
<211> 25
<212> DNA
<213> 人工序列()
<400> 203
ttttttttcc gcaggtcctc gcgtt 25
<210> 204
<211> 28
<212> DNA
<213> 人工序列()
<400> 204
ttttttttgc ctcttggtcc cctcccta 28
<210> 205
<211> 35
<212> DNA
<213> 人工序列()
<400> 205
tttttttttg ggacatgaga gttaatagat ccaca 35
<210> 206
<211> 32
<212> DNA
<213> 人工序列()
<400> 206
tttttttttt actcacgctt tgagcaaatg ac 32
<210> 207
<211> 34
<212> DNA
<213> 人工序列()
<400> 207
tttttttttg gccgtaaact gctttgtgaa taat 34
<210> 208
<211> 35
<212> DNA
<213> 人工序列()
<400> 208
ttttttttgc caataaaact ctttccaact caagg 35
<210> 209
<211> 36
<212> DNA
<213> 人工序列()
<400> 209
ttttttttaa tcatgttaca aagtaagtgt gggaac 36
<210> 210
<211> 34
<212> DNA
<213> 人工序列()
<400> 210
ttttttttat tcatttctgc cttcatcacc aaac 34
<210> 211
<211> 36
<212> DNA
<213> 人工序列()
<400> 211
tttttttttc agtttggcat taaggtttct ttttca 36
<210> 212
<211> 29
<212> DNA
<213> 人工序列()
<400> 212
tttttttttt aaagagcccg ctctcatcg 29
<210> 213
<211> 30
<212> DNA
<213> 人工序列()
<400> 213
ttttttttcc tccagaacaa tgatgggctt 30
<210> 214
<211> 30
<212> DNA
<213> 人工序列()
<400> 214
ttttttttac tcactaggtt ctcactcgct 30
<210> 215
<211> 34
<212> DNA
<213> 人工序列()
<400> 215
ttttttttga acagacaagg acactgaaat aacc 34
<210> 216
<211> 35
<212> DNA
<213> 人工序列()
<400> 216
ttttttttgc ttttcactgg acactcatat cttct 35
<210> 217
<211> 34
<212> DNA
<213> 人工序列()
<400> 217
ttttttttgg aaaatagtat ggaagactga gtta 34
<210> 218
<211> 30
<212> DNA
<213> 人工序列()
<400> 218
ttttttttag atttgagcca ccaactgtgc 30
<210> 219
<211> 34
<212> DNA
<213> 人工序列()
<400> 219
ttttttttgc ttcttactgt tgtgtggtac aaac 34
<210> 220
<211> 33
<212> DNA
<213> 人工序列()
<400> 220
ttttttttat actgtctcac caactgtctg cta 33
<210> 221
<211> 35
<212> DNA
<213> 人工序列()
<400> 221
ttttttttga aaatcaaaca ctgaatattc tgatt 35
<210> 222
<211> 35
<212> DNA
<213> 人工序列()
<400> 222
ttttttttgc tatgtccaca tcattctgag ttttt 35
<210> 223
<211> 36
<212> DNA
<213> 人工序列()
<400> 223
tttttttttt tccccagtat gagaataatg ttatca 36
<210> 224
<211> 34
<212> DNA
<213> 人工序列()
<400> 224
tttttttttt gaggcatgat agactacatt cctg 34
<210> 225
<211> 30
<212> DNA
<213> 人工序列()
<400> 225
ttttttttaa gattcttggc agcggttctt 30
<210> 226
<211> 33
<212> DNA
<213> 人工序列()
<400> 226
ttttttttat ccagttgttc cccatttact gtc 33
<210> 227
<211> 36
<212> DNA
<213> 人工序列()
<400> 227
tttttttttt ttaattcctt ttctcctttt caatac 36
<210> 228
<211> 29
<212> DNA
<213> 人工序列()
<400> 228
ttttttttac cagcttttag accctgcat 29
<210> 229
<211> 35
<212> DNA
<213> 人工序列()
<400> 229
ttttttttgt tgatgaaaaa gcacctgaat tctca 35
<210> 230
<211> 35
<212> DNA
<213> 人工序列()
<400> 230
ttttttttgc ccagccacta ttactttttc ttgaa 35
<210> 231
<211> 34
<212> DNA
<213> 人工序列()
<400> 231
tttttttttg tccattaaaa gcatatatgt ctgt 34
<210> 232
<211> 33
<212> DNA
<213> 人工序列()
<400> 232
tttttttttt caacagggcc tttctattta ggt 33
<210> 233
<211> 35
<212> DNA
<213> 人工序列()
<400> 233
ttttttttca atagttgtct ttcttccact caggt 35
<210> 234
<211> 34
<212> DNA
<213> 人工序列()
<400> 234
ttttttttaa gggactccag tataactgaa atgc 34
<210> 235
<211> 35
<212> DNA
<213> 人工序列()
<400> 235
tttttttttt tttctgtgct ttttcctgtt tcaga 35
<210> 236
<211> 34
<212> DNA
<213> 人工序列()
<400> 236
ttttttttaa actcatgacc ttcaaagatg tctt 34
<210> 237
<211> 29
<212> DNA
<213> 人工序列()
<400> 237
ttttttttgg aaacagctta gtgggtgtg 29
<210> 238
<211> 27
<212> DNA
<213> 人工序列()
<400> 238
ttttttttga aaaggcgcac tgtggtg 27
<210> 239
<211> 25
<212> DNA
<213> 人工序列()
<400> 239
ttttttttcg gccgaggtcg gcttc 25
<210> 240
<211> 26
<212> DNA
<213> 人工序列()
<400> 240
ttttttttac ctgccggccc catgta 26
<210> 241
<211> 26
<212> DNA
<213> 人工序列()
<400> 241
ttttttttcg cccgggaggt gttcaa 26
<210> 242
<211> 27
<212> DNA
<213> 人工序列()
<400> 242
ttttttttcc actctctgag gcgggaa 27
<210> 243
<211> 37
<212> DNA
<213> 人工序列()
<400> 243
ttttttttac agtgcttgaa catgtaatat ctcaaat 37
<210> 244
<211> 36
<212> DNA
<213> 人工序列()
<400> 244
ttttttttaa acttcaactc tatactgacg aaccag 36
<210> 245
<211> 34
<212> DNA
<213> 人工序列()
<400> 245
tttttttttt taaggagcaa agaatctgca gagt 34
<210> 246
<211> 37
<212> DNA
<213> 人工序列()
<400> 246
ttttttttag gaagataatt accttatatg ccaaata 37
<210> 247
<211> 34
<212> DNA
<213> 人工序列()
<400> 247
ttttttttag aatagagctg gaaataaggc atcc 34
<210> 248
<211> 38
<212> DNA
<213> 人工序列()
<400> 248
ttttttttgt gtctcaaacc attctactat cacaatct 38
<210> 249
<211> 36
<212> DNA
<213> 人工序列()
<400> 249
ttttttttga gtttggattt ttcctttttg cttata 36
<210> 250
<211> 30
<212> DNA
<213> 人工序列()
<400> 250
ttttttttcc acaacaccaa tggaagctga 30
<210> 251
<211> 31
<212> DNA
<213> 人工序列()
<400> 251
ttttttttct taggcttctc ctggcaatct c 31
<210> 252
<211> 33
<212> DNA
<213> 人工序列()
<400> 252
ttttttttgg gaattcacac agtcctagtt tcc 33
<210> 253
<211> 32
<212> DNA
<213> 人工序列()
<400> 253
ttttttttgg tgttaaaatg tccgcagttg at 32
<210> 254
<211> 30
<212> DNA
<213> 人工序列()
<400> 254
ttttttttgt ctctcctccg ggtaaaacac 30
<210> 255
<211> 32
<212> DNA
<213> 人工序列()
<400> 255
ttttttttga tcagttctcc aatcttgagg ct 32
<210> 256
<211> 35
<212> DNA
<213> 人工序列()
<400> 256
ttttttttaa cagtatcatg tcaattaaag agcct 35
<210> 257
<211> 37
<212> DNA
<213> 人工序列()
<400> 257
tttttttttt catttttgct tttcttattc cttttct 37
<210> 258
<211> 30
<212> DNA
<213> 人工序列()
<400> 258
tttttttttg cctttcaaca accggttgag 30
<210> 259
<211> 34
<212> DNA
<213> 人工序列()
<400> 259
tttttttttt caaagaggag gaattctgat caca 34
<210> 260
<211> 37
<212> DNA
<213> 人工序列()
<400> 260
ttttttttat tcacatttat aatccatgta cctgatt 37
<210> 261
<211> 32
<212> DNA
<213> 人工序列()
<400> 261
ttttttttgg agagcagatg aatagtgctg ta 32
<210> 262
<211> 35
<212> DNA
<213> 人工序列()
<400> 262
ttttttttca cagtttaggt tttgagataa atatg 35
<210> 263
<211> 36
<212> DNA
<213> 人工序列()
<400> 263
ttttttttag aactggatcc agtggtatag aaatct 36
<210> 264
<211> 33
<212> DNA
<213> 人工序列()
<400> 264
ttttttttac tggctgaagt caaaagtagt cag 33
<210> 265
<211> 35
<212> DNA
<213> 人工序列()
<400> 265
ttttttttaa ttttaggttg cagtttcatc actgt 35
<210> 266
<211> 31
<212> DNA
<213> 人工序列()
<400> 266
ttttttttac ctgaaaaagg ttaagggctc t 31
<210> 267
<211> 36
<212> DNA
<213> 人工序列()
<400> 267
ttttttttta aggttttcac taatgagctt gccatt 36
<210> 268
<211> 33
<212> DNA
<213> 人工序列()
<400> 268
ttttttttgt tcttatccat gagaggctgc tta 33
<210> 269
<211> 33
<212> DNA
<213> 人工序列()
<400> 269
ttttttttgc tgccttgctg aataagtgta aaa 33
<210> 270
<211> 35
<212> DNA
<213> 人工序列()
<400> 270
ttttttttaa gtggtataat catgtgggta actgc 35
<210> 271
<211> 39
<212> DNA
<213> 人工序列()
<400> 271
tttttttttc aagcttttta aatggaattt tgagctgat 39
<210> 272
<211> 35
<212> DNA
<213> 人工序列()
<400> 272
tttttttttc ttcttgtaaa gtctgcctca attct 35
<210> 273
<211> 35
<212> DNA
<213> 人工序列()
<400> 273
tttttttttt atttcagatt gaatttagtg gaagc 35
<210> 274
<211> 36
<212> DNA
<213> 人工序列()
<400> 274
ttttttttag ttgatttata ccctgataga gtcggt 36
<210> 275
<211> 33
<212> DNA
<213> 人工序列()
<400> 275
tttttttttt gccaagaagt ttcaaagaca agc 33
<210> 276
<211> 35
<212> DNA
<213> 人工序列()
<400> 276
ttttttttga cagcacattg ccaagtatat attgt 35
<210> 277
<211> 36
<212> DNA
<213> 人工序列()
<400> 277
ttttttttac cttttggatc aaatgatgct tgttta 36
<210> 278
<211> 33
<212> DNA
<213> 人工序列()
<400> 278
ttttttttct tggagaagtc agaacgaaga tca 33
<210> 279
<211> 36
<212> DNA
<213> 人工序列()
<400> 279
ttttttttcc agaaattatt gttggcagtt tttgtg 36
<210> 280
<211> 35
<212> DNA
<213> 人工序列()
<400> 280
ttttttttta caaactttct taaagtggcc tttgc 35
<210> 281
<211> 35
<212> DNA
<213> 人工序列()
<400> 281
tttttttttg aaaacagtaa aatttaagtg ggagg 35
<210> 282
<211> 34
<212> DNA
<213> 人工序列()
<400> 282
tttttttttt cactgagatt aggatcaaat gaag 34
<210> 283
<211> 35
<212> DNA
<213> 人工序列()
<400> 283
ttttttttga ttttgtcact ttgttctgtt tgcag 35
<210> 284
<211> 33
<212> DNA
<213> 人工序列()
<400> 284
ttttttttca acctccaatg acccattctt acc 33
<210> 285
<211> 34
<212> DNA
<213> 人工序列()
<400> 285
ttttttttag tcaacattaa taagtgcagc caga 34
<210> 286
<211> 30
<212> DNA
<213> 人工序列()
<400> 286
tttttttttg ttgggcgatt tctgtttgac 30
<210> 287
<211> 39
<212> DNA
<213> 人工序列()
<400> 287
ttttttttac attgaaaaat ggtagtaggt atttatgga 39
<210> 288
<211> 40
<212> DNA
<213> 人工序列()
<400> 288
ttttttttgt ttttattgtt acgaaggact ttttcttcct 40
<210> 289
<211> 37
<212> DNA
<213> 人工序列()
<400> 289
ttttttttag tttggatatt actttcgtgt aacctgt 37
<210> 290
<211> 37
<212> DNA
<213> 人工序列()
<400> 290
tttttttttt cacatcatgt tagagcattt agggaat 37
<210> 291
<211> 36
<212> DNA
<213> 人工序列()
<400> 291
ttttttttac tttggatatg tttcacgtag tacaca 36
<210> 292
<211> 32
<212> DNA
<213> 人工序列()
<400> 292
ttttttttgg catcctgggc ttcttcatat tc 32
<210> 293
<211> 38
<212> DNA
<213> 人工序列()
<400> 293
tttttttttg cagcaaattg acttctttaa atgaagag 38
<210> 294
<211> 33
<212> DNA
<213> 人工序列()
<400> 294
tttttttttt accaaaagcc aggtgacatt cag 33
<210> 295
<211> 34
<212> DNA
<213> 人工序列()
<400> 295
ttttttttga aatgggtttt gaattcccaa atgg 34
<210> 296
<211> 32
<212> DNA
<213> 人工序列()
<400> 296
ttttttttac aacagcatct agctgagcta ac 32
<210> 297
<211> 34
<212> DNA
<213> 人工序列()
<400> 297
ttttttttat acaggctatg tagaaccaat gcag 34
<210> 298
<211> 37
<212> DNA
<213> 人工序列()
<400> 298
ttttttttgc atgcctggat gcttttaata taattct 37
<210> 299
<211> 30
<212> DNA
<213> 人工序列()
<400> 299
ttttttttga gcacctgttc catatgtacg 30
<210> 300
<211> 37
<212> DNA
<213> 人工序列()
<400> 300
tttttttttt ttaccagtaa tgatgtggaa catctgt 37
<210> 301
<211> 40
<212> DNA
<213> 人工序列()
<400> 301
ttttttttat tgcatttatt cctaatgacg tatactttga 40
<210> 302
<211> 40
<212> DNA
<213> 人工序列()
<400> 302
ttttttttga actgggaatt ttctccatca attttaaata 40
<210> 303
<211> 34
<212> DNA
<213> 人工序列()
<400> 303
ttttttttac ctacgcgatt aatcatcagt gtac 34
<210> 304
<211> 33
<212> DNA
<213> 人工序列()
<400> 304
ttttttttcc caatttgggc catgagtact atc 33
<210> 305
<211> 32
<212> DNA
<213> 人工序列()
<400> 305
ttttttttgc cccaatatgg gaggtaaatc aa 32
<210> 306
<211> 32
<212> DNA
<213> 人工序列()
<400> 306
ttttttttac gtggagactc ctttcaattg ac 32
<210> 307
<211> 30
<212> DNA
<213> 人工序列()
<400> 307
ttttttttga ctgcatctta gcccgagtag 30
<210> 308
<211> 36
<212> DNA
<213> 人工序列()
<400> 308
ttttttttct gcaaatatac ttttccttct cacagg 36
<210> 309
<211> 34
<212> DNA
<213> 人工序列()
<400> 309
ttttttttgg catatccttc ccaatgtatt gtct 34
<210> 310
<211> 34
<212> DNA
<213> 人工序列()
<400> 310
ttttttttct aacccaaatc catcgtaggt agaa 34
<210> 311
<211> 32
<212> DNA
<213> 人工序列()
<400> 311
ttttttttaa ttatgtgctt caggtctgca ac 32
<210> 312
<211> 34
<212> DNA
<213> 人工序列()
<400> 312
ttttttttca aggcagtaag ttcatgaaaa tggg 34
<210> 313
<211> 35
<212> DNA
<213> 人工序列()
<400> 313
tttttttttg ggctatatca gaatacattg caaca 35
<210> 314
<211> 35
<212> DNA
<213> 人工序列()
<400> 314
ttttttttac atacctttct tcacctgata aagca 35
<210> 315
<211> 32
<212> DNA
<213> 人工序列()
<400> 315
ttttttttct tggccaatca gataccaact gt 32
<210> 316
<211> 34
<212> DNA
<213> 人工序列()
<400> 316
ttttttttag gcaattactg atgatttcaa gggt 34
<210> 317
<211> 36
<212> DNA
<213> 人工序列()
<400> 317
ttttttttta cataaattgc tgtctcttct catgct 36
<210> 318
<211> 32
<212> DNA
<213> 人工序列()
<400> 318
ttttttttca agttccaggg ctttctgttt ag 32
<210> 319
<211> 33
<212> DNA
<213> 人工序列()
<400> 319
ttttttttcg cttccccaaa tttcttatag gtg 33
<210> 320
<211> 33
<212> DNA
<213> 人工序列()
<400> 320
tttttttttt gctgctggtt ccatgatatc ata 33
<210> 321
<211> 36
<212> DNA
<213> 人工序列()
<400> 321
ttttttttgg aacttgagga gtttcagtat attgga 36
<210> 322
<211> 38
<212> DNA
<213> 人工序列()
<400> 322
ttttttttaa aaccttcatc ttagtgtcct gtttatgt 38
<210> 323
<211> 36
<212> DNA
<213> 人工序列()
<400> 323
ttttttttga tggaaatgaa acaatttgtc actgtc 36
<210> 324
<211> 33
<212> DNA
<213> 人工序列()
<400> 324
ttttttttgt aaagggcatt tgtttcacct tgg 33
<210> 325
<211> 36
<212> DNA
<213> 人工序列()
<400> 325
ttttttttta ctaatgggac attcacatgt gtttca 36
<210> 326
<211> 37
<212> DNA
<213> 人工序列()
<400> 326
ttttttttct ttgctattac ttcagctttt agctgtt 37
<210> 327
<211> 37
<212> DNA
<213> 人工序列()
<400> 327
ttttttttcc ctttactgaa atgtcagaag aaaacat 37
<210> 328
<211> 37
<212> DNA
<213> 人工序列()
<400> 328
ttttttttca gacaatagct tatcaatatt accttca 37
<210> 329
<211> 33
<212> DNA
<213> 人工序列()
<400> 329
ttttttttac gaataaaagt tactacgtga aaa 33
<210> 330
<211> 32
<212> DNA
<213> 人工序列()
<400> 330
ttttttttca tgggcactga cagttaacac ta 32
<210> 331
<211> 25
<212> DNA
<213> 人工序列()
<400> 331
ttttttttga gccgcgcggt agatg 25
<210> 332
<211> 25
<212> DNA
<213> 人工序列()
<400> 332
ttttttttgg ccgccttcgc gtgag 25
<210> 333
<211> 25
<212> DNA
<213> 人工序列()
<400> 333
ttttttttca agtctccggc gctga 25
<210> 334
<211> 26
<212> DNA
<213> 人工序列()
<400> 334
ttttttttct tcgccttggg cggtga 26
<210> 335
<211> 25
<212> DNA
<213> 人工序列()
<400> 335
ttttttttga tgcggcctgg agcga 25
<210> 336
<211> 25
<212> DNA
<213> 人工序列()
<400> 336
ttttttttcg ctatgccccc gcctt 25
<210> 337
<211> 27
<212> DNA
<213> 人工序列()
<400> 337
ttttttttct gctgccccca ccaggta 27
<210> 338
<211> 29
<212> DNA
<213> 人工序列()
<400> 338
ttttttttga cccctgcact cattcaagc 29
<210> 339
<211> 33
<212> DNA
<213> 人工序列()
<400> 339
ttttttttaa ctgcctttaa ggaaacttga cca 33
<210> 340
<211> 29
<212> DNA
<213> 人工序列()
<400> 340
tttttttttc cctttctcgc ggatgaatg 29
<210> 341
<211> 31
<212> DNA
<213> 人工序列()
<400> 341
ttttttttgg agatttggtt tgggccaaga t 31
<210> 342
<211> 33
<212> DNA
<213> 人工序列()
<400> 342
ttttttttgc tttaaaagcc ttttgctaac cca 33
<210> 343
<211> 32
<212> DNA
<213> 人工序列()
<400> 343
ttttttttga aagggaaatc agtccgtgtt ca 32
<210> 344
<211> 32
<212> DNA
<213> 人工序列()
<400> 344
ttttttttaa aaagtctgcc tgtctgtctg tt 32
<210> 345
<211> 34
<212> DNA
<213> 人工序列()
<400> 345
ttttttttcc tggcatatat atattttaag atag 34
<210> 346
<211> 33
<212> DNA
<213> 人工序列()
<400> 346
ttttttttca ctgtaaaaat gacctccctt ctg 33
<210> 347
<211> 31
<212> DNA
<213> 人工序列()
<400> 347
ttttttttac ccggccctta ttgtttataa a 31
<210> 348
<211> 32
<212> DNA
<213> 人工序列()
<400> 348
ttttttttca tcacaaactg ccaattcaag cc 32
<210> 349
<211> 32
<212> DNA
<213> 人工序列()
<400> 349
tttttttttg aaatactgag agcaatgcaa cg 32
<210> 350
<211> 32
<212> DNA
<213> 人工序列()
<400> 350
tttttttttc ttcccccatc accctaacat aa 32
<210> 351
<211> 30
<212> DNA
<213> 人工序列()
<400> 351
tttttttttg cacgggtacc attataaagt 30
<210> 352
<211> 35
<212> DNA
<213> 人工序列()
<400> 352
tttttttttg tacttcctct tcactctcaa tttca 35
<210> 353
<211> 29
<212> DNA
<213> 人工序列()
<400> 353
ttttttttct ggcaggtagg cacaactta 29
<210> 354
<211> 30
<212> DNA
<213> 人工序列()
<400> 354
ttttttttaa ttccacatca gagccaccaa 30
<210> 355
<211> 34
<212> DNA
<213> 人工序列()
<400> 355
ttttttttaa cgaagggtca tatcagattc tgag 34
<210> 356
<211> 30
<212> DNA
<213> 人工序列()
<400> 356
ttttttttat tctcttccgc tttcgagcaa 30
<210> 357
<211> 33
<212> DNA
<213> 人工序列()
<400> 357
ttttttttgc agtgatgaaa taagcagtgg agt 33
<210> 358
<211> 34
<212> DNA
<213> 人工序列()
<400> 358
tttttttttc tgatgaaatg ctagttgctt gttt 34
<210> 359
<211> 34
<212> DNA
<213> 人工序列()
<400> 359
tttttttttc tcttaaaagg aaaagctcta ggaa 34
<210> 360
<211> 31
<212> DNA
<213> 人工序列()
<400> 360
ttttttttat accaaacagt agggcgacta c 31
<210> 361
<211> 32
<212> DNA
<213> 人工序列()
<400> 361
tttttttttc tgcccctcaa aattctgaat cc 32
<210> 362
<211> 36
<212> DNA
<213> 人工序列()
<400> 362
ttttttttgc acatagagtg tagatgcatc aaaatc 36
<210> 363
<211> 36
<212> DNA
<213> 人工序列()
<400> 363
ttttttttat gaaactttag aatggcttaa ggagga 36
<210> 364
<211> 35
<212> DNA
<213> 人工序列()
<400> 364
ttttttttat caaagttctg agacttaatc tgcca 35
<210> 365
<211> 34
<212> DNA
<213> 人工序列()
<400> 365
ttttttttta tgtgcctgag gatttcctca attc 34
<210> 366
<211> 31
<212> DNA
<213> 人工序列()
<400> 366
tttttttttt catgaatacc agccccagtt c 31
<210> 367
<211> 32
<212> DNA
<213> 人工序列()
<400> 367
ttttttttgg gaaattttat gagctgtacc ac 32
<210> 368
<211> 30
<212> DNA
<213> 人工序列()
<400> 368
ttttttttca gtctgttcca ctcgtgctac 30
<210> 369
<211> 32
<212> DNA
<213> 人工序列()
<400> 369
ttttttttgt tattcagatt ccctggtgca ga 32
<210> 370
<211> 32
<212> DNA
<213> 人工序列()
<400> 370
ttttttttca ctgtaagtct gtgtaccctt gg 32
<210> 371
<211> 35
<212> DNA
<213> 人工序列()
<400> 371
ttttttttta tccaagtatg atagagtggt gagga 35
<210> 372
<211> 30
<212> DNA
<213> 人工序列()
<400> 372
ttttttttgc acacaccata tgcacgagta 30
<210> 373
<211> 33
<212> DNA
<213> 人工序列()
<400> 373
ttttttttgg tgatccctct gagaactaca gta 33
<210> 374
<211> 34
<212> DNA
<213> 人工序列()
<400> 374
ttttttttcc actagagtcc taaatctcga acaa 34
<210> 375
<211> 33
<212> DNA
<213> 人工序列()
<400> 375
ttttttttgt gctttgttga tacttcactg gga 33
<210> 376
<211> 34
<212> DNA
<213> 人工序列()
<400> 376
ttttttttag aacaggacaa tgaactcttt agaa 34
<210> 377
<211> 33
<212> DNA
<213> 人工序列()
<400> 377
ttttttttca cactatcccc cagtacaagt ttt 33
<210> 378
<211> 34
<212> DNA
<213> 人工序列()
<400> 378
tttttttttt cttcctcaag gagagttctc aaag 34
<210> 379
<211> 34
<212> DNA
<213> 人工序列()
<400> 379
ttttttttct gttctcttca ggaaggtctg atac 34
<210> 380
<211> 32
<212> DNA
<213> 人工序列()
<400> 380
tttttttttg tcaacccaat ggaatcagac tc 32
<210> 381
<211> 32
<212> DNA
<213> 人工序列()
<400> 381
tttttttttg ttaccccagg tgcttaaagg ta 32
<210> 382
<211> 37
<212> DNA
<213> 人工序列()
<400> 382
ttttttttca aaattagcca ttgataaaag ctcctga 37
<210> 383
<211> 32
<212> DNA
<213> 人工序列()
<400> 383
ttttttttgc tctaggtggt tgtgtcttct ac 32
<210> 384
<211> 33
<212> DNA
<213> 人工序列()
<400> 384
tttttttttt aatgtcactg catctagcac cat 33
<210> 385
<211> 34
<212> DNA
<213> 人工序列()
<400> 385
ttttttttac tacaagatct ggtgctatct tcac 34
<210> 386
<211> 30
<212> DNA
<213> 人工序列()
<400> 386
ttttttttat tgctttagga gccgcttacc 30
<210> 387
<211> 33
<212> DNA
<213> 人工序列()
<400> 387
ttttttttta ctgaaggaac cctactagag agg 33
<210> 388
<211> 33
<212> DNA
<213> 人工序列()
<400> 388
ttttttttgc tctacaactt cggagatttt gtc 33
<210> 389
<211> 33
<212> DNA
<213> 人工序列()
<400> 389
ttttttttcg tctagatgcc atagaagacc tca 33
<210> 390
<211> 35
<212> DNA
<213> 人工序列()
<400> 390
ttttttttag tttcttcata cattatagcc ctgct 35
<210> 391
<211> 32
<212> DNA
<213> 人工序列()
<400> 391
ttttttttct cagtaaaatt cataatgttg gg 32
<210> 392
<211> 36
<212> DNA
<213> 人工序列()
<400> 392
ttttttttca gcaacttctt ccatgatccc tataat 36
<210> 393
<211> 34
<212> DNA
<213> 人工序列()
<400> 393
tttttttttc tgctctggaa ggattcaaag taat 34
<210> 394
<211> 30
<212> DNA
<213> 人工序列()
<400> 394
ttttttttgg tcaaaggctg tatcccatcg 30
<210> 395
<211> 34
<212> DNA
<213> 人工序列()
<400> 395
ttttttttgg tcgttttcct gatttgactg taga 34
<210> 396
<211> 33
<212> DNA
<213> 人工序列()
<400> 396
ttttttttgt ttctctaggt attccaggag gct 33
<210> 397
<211> 36
<212> DNA
<213> 人工序列()
<400> 397
tttttttttc ttgctgacat aagagaaaat gaacag 36
<210> 398
<211> 35
<212> DNA
<213> 人工序列()
<400> 398
ttttttttag atttcaactc gtattcttct ggcaa 35
<210> 399
<211> 31
<212> DNA
<213> 人工序列()
<400> 399
ttttttttcc tgagaatttc accactcgca a 31
<210> 400
<211> 30
<212> DNA
<213> 人工序列()
<400> 400
ttttttttag ttatagaaca gtcgccgcat 30
<210> 401
<211> 32
<212> DNA
<213> 人工序列()
<400> 401
ttttttttca taaatgctga agaacggagg ga 32
<210> 402
<211> 33
<212> DNA
<213> 人工序列()
<400> 402
ttttttttct ggcaaacagc actacttatc aaa 33
<210> 403
<211> 32
<212> DNA
<213> 人工序列()
<400> 403
ttttttttac ttaggctgat aaaaccccca aa 32
<210> 404
<211> 32
<212> DNA
<213> 人工序列()
<400> 404
ttttttttat ggcgtgatcc tttaagctct aa 32
<210> 405
<211> 30
<212> DNA
<213> 人工序列()
<400> 405
tttttttttg tgcctggcta actatagtcg 30
<210> 406
<211> 32
<212> DNA
<213> 人工序列()
<400> 406
tttttttttc ctcacagcct attagaatgt ca 32
<210> 407
<211> 30
<212> DNA
<213> 人工序列()
<400> 407
ttttttttcg ccatccttgc attacgaaga 30
<210> 408
<211> 34
<212> DNA
<213> 人工序列()
<400> 408
ttttttttag aatcagttac ctgtctcata agcg 34
<210> 409
<211> 32
<212> DNA
<213> 人工序列()
<400> 409
ttttttttag gaaaatggca aagcctattg tg 32
<210> 410
<211> 36
<212> DNA
<213> 人工序列()
<400> 410
ttttttttgc tgacttttat gtaactgtgt ttggaa 36
<210> 411
<211> 31
<212> DNA
<213> 人工序列()
<400> 411
ttttttttgc ctagctctta cgtaagggtt c 31
<210> 412
<211> 32
<212> DNA
<213> 人工序列()
<400> 412
ttttttttca ctctatcaat tggtgtgagc ct 32
<210> 413
<211> 29
<212> DNA
<213> 人工序列()
<400> 413
ttttttttca gatgggttgt tacgtccct 29
<210> 414
<211> 36
<212> DNA
<213> 人工序列()
<400> 414
ttttttttag gctcatatac aagaagcaaa tatctt 36
<210> 415
<211> 39
<212> DNA
<213> 人工序列()
<400> 415
ttttttttat gtgtagctca tgatagctat ataacctag 39
<210> 416
<211> 28
<212> DNA
<213> 人工序列()
<400> 416
ttttttttac aagcaccaga gaatgtgc 28
<210> 417
<211> 29
<212> DNA
<213> 人工序列()
<400> 417
ttttttttcc agcatactca tgcatgcaa 29
<210> 418
<211> 35
<212> DNA
<213> 人工序列()
<400> 418
tttttttttg cgtgctctaa aaacattcat attgt 35
<210> 419
<211> 33
<212> DNA
<213> 人工序列()
<400> 419
ttttttttcg atgttgcttt tctgtcctag cat 33
<210> 420
<211> 36
<212> DNA
<213> 人工序列()
<400> 420
ttttttttac gacattttat agtctcagca agttct 36
<210> 421
<211> 34
<212> DNA
<213> 人工序列()
<400> 421
ttttttttac tttaacagga agaggtactg caac 34
<210> 422
<211> 34
<212> DNA
<213> 人工序列()
<400> 422
ttttttttgc gcacagcaac attttgagaa taat 34
<210> 423
<211> 38
<212> DNA
<213> 人工序列()
<400> 423
ttttttttat gtcgtacatt attttcaact cactacca 38
<210> 424
<211> 38
<212> DNA
<213> 人工序列()
<400> 424
ttttttttga aaaatattag cgatacatgt gctagcaa 38
<210> 425
<211> 31
<212> DNA
<213> 人工序列()
<400> 425
ttttttttgc gcctaggaca tatggtatgt g 31
<210> 426
<211> 32
<212> DNA
<213> 人工序列()
<400> 426
ttttttttga ggaacgtaat agtctcctgg ct 32
<210> 427
<211> 33
<212> DNA
<213> 人工序列()
<400> 427
ttttttttgg catgcatggt agaaaatgaa tgt 33
<210> 428
<211> 38
<212> DNA
<213> 人工序列()
<400> 428
ttttttttct tctcaaattc tcttgctttt ctatgtcc 38
<210> 429
<211> 34
<212> DNA
<213> 人工序列()
<400> 429
ttttttttct tgctaatctc ccagaggaag ttat 34
<210> 430
<211> 34
<212> DNA
<213> 人工序列()
<400> 430
tttttttttc atcccttccc cttttactgt ttct 34
<210> 431
<211> 33
<212> DNA
<213> 人工序列()
<400> 431
ttttttttgg aagggatgat gcactatgaa aaa 33
<210> 432
<211> 34
<212> DNA
<213> 人工序列()
<400> 432
ttttttttag tcaactcaaa gcttccaatg tagt 34
<210> 433
<211> 34
<212> DNA
<213> 人工序列()
<400> 433
ttttttttgc tagtgaaagg tcaactgtag atgc 34
<210> 434
<211> 35
<212> DNA
<213> 人工序列()
<400> 434
tttttttttg ttgtctgaat ttaccacctt tgtca 35
<210> 435
<211> 25
<212> DNA
<213> 人工序列()
<400> 435
ttttttttgt ggaagccgtg ggctc 25
<210> 436
<211> 25
<212> DNA
<213> 人工序列()
<400> 436
ttttttttaa ctctccggcg ttccc 25
<210> 437
<211> 25
<212> DNA
<213> 人工序列()
<400> 437
ttttttttgg gtctgagtcg cctgt 25
<210> 438
<211> 26
<212> DNA
<213> 人工序列()
<400> 438
tttttttttt aaaaccggcc cgggtc 26
<210> 439
<211> 25
<212> DNA
<213> 人工序列()
<400> 439
ttttttttcg gcggctggca catcc 25
<210> 440
<211> 28
<212> DNA
<213> 人工序列()
<400> 440
tttttttttt ctcctcagca gccagagg 28
<210> 441
<211> 26
<212> DNA
<213> 人工序列()
<400> 441
ttttttttgc agccgttcgg aggatt 26
<210> 442
<211> 25
<212> DNA
<213> 人工序列()
<400> 442
ttttttttct gatgcccctc gctct 25
<210> 443
<211> 25
<212> DNA
<213> 人工序列()
<400> 443
ttttttttcc ggctgcggtc cagag 25
<210> 444
<211> 32
<212> DNA
<213> 人工序列()
<400> 444
ttttttttcg atctctttga tgatggctgt ca 32
<210> 445
<211> 31
<212> DNA
<213> 人工序列()
<400> 445
ttttttttgc catctctctc ctcctttttc t 31
<210> 446
<211> 33
<212> DNA
<213> 人工序列()
<400> 446
ttttttttcg ttctaagaga gtgacagaaa ggt 33
<210> 447
<211> 34
<212> DNA
<213> 人工序列()
<400> 447
tttttttttc ttttagtttg attgctgcat attt 34
<210> 448
<211> 35
<212> DNA
<213> 人工序列()
<400> 448
tttttttttc aaagcattct taccttacta catca 35
<210> 449
<211> 37
<212> DNA
<213> 人工序列()
<400> 449
ttttttttag tactcagata tttatccaaa cattatt 37
<210> 450
<211> 35
<212> DNA
<213> 人工序列()
<400> 450
ttttttttag aaatcttttc taaatgaaaa cacaa 35
<210> 451
<211> 35
<212> DNA
<213> 人工序列()
<400> 451
ttttttttgt tagctcattt ttgttaatgg tggct 35
<210> 452
<211> 34
<212> DNA
<213> 人工序列()
<400> 452
ttttttttct aacaagcaga taactttcac ttaa 34
<210> 453
<211> 37
<212> DNA
<213> 人工序列()
<400> 453
tttttttttg tgtcacatta taaagattca ggcaatg 37
<210> 454
<211> 35
<212> DNA
<213> 人工序列()
<400> 454
ttttttttgt acagtacatt catacctacc tctgc 35
<210> 455
<211> 34
<212> DNA
<213> 人工序列()
<400> 455
ttttttttct tttagttgtg ctgaaagaca ttat 34
<210> 456
<211> 36
<212> DNA
<213> 人工序列()
<400> 456
tttttttttg tatctcactc gataatctgg atgact 36
<210> 457
<211> 35
<212> DNA
<213> 人工序列()
<400> 457
ttttttttgc aacatttcta aagttaccta cttgt 35
<210> 458
<211> 33
<212> DNA
<213> 人工序列()
<400> 458
ttttttttat cttcacttag ccattggtca aga 33
<210> 459
<211> 31
<212> DNA
<213> 人工序列()
<400> 459
ttttttttac ccaccacagc tagaacttat c 31
<210> 460
<211> 29
<212> DNA
<213> 人工序列()
<400> 460
ttttttttag ggcctcttgt gcctttaaa 29
<210> 461
<211> 35
<212> DNA
<213> 人工序列()
<400> 461
ttttttttga aagggacgaa ctggtgtaat gatat 35
<210> 462
<211> 36
<212> DNA
<213> 人工序列()
<400> 462
tttttttttt ccaataaatt ctcagatcca ggaaga 36
<210> 463
<211> 33
<212> DNA
<213> 人工序列()
<400> 463
ttttttttac gacccagtta ccatagcaat tta 33
<210> 464
<211> 32
<212> DNA
<213> 人工序列()
<400> 464
ttttttttag tgccactggt ctataatcca ga 32
<210> 465
<211> 33
<212> DNA
<213> 人工序列()
<400> 465
ttttttttag tcagaggcgc tatgtgtatt att 33
<210> 466
<211> 35
<212> DNA
<213> 人工序列()
<400> 466
ttttttttag aaaactgttc caatacatgg aagga 35
<210> 467
<211> 30
<212> DNA
<213> 人工序列()
<400> 467
ttttttttcg gaacttgcag taagtgcttg 30
<210> 468
<211> 36
<212> DNA
<213> 人工序列()
<400> 468
ttttttttaa tgcttcagaa atatagtctc ctgcat 36
<210> 469
<211> 35
<212> DNA
<213> 人工序列()
<400> 469
ttttttttcg tttttgacag tttgacagtt aaagg 35
<210> 470
<211> 35
<212> DNA
<213> 人工序列()
<400> 470
ttttttttgg gaactcaaag tacatgaact tgtct 35
<210> 471
<211> 35
<212> DNA
<213> 人工序列()
<400> 471
ttttttttgc cagctaaagg tgaagatata ttcct 35
<210> 472
<211> 37
<212> DNA
<213> 人工序列()
<400> 472
tttttttttc tcccaatgaa agtaaagtac aaacctt 37
<210> 473
<211> 33
<212> DNA
<213> 人工序列()
<400> 473
ttttttttgt tacctgtgtg tggtgatatc aaa 33
<210> 474
<211> 36
<212> DNA
<213> 人工序列()
<400> 474
tttttttttg cagatctaat agaaaacaaa ttatag 36
<210> 475
<211> 37
<212> DNA
<213> 人工序列()
<400> 475
ttttttttaa atgtttaaca taggtgacag attttct 37
<210> 476
<211> 34
<212> DNA
<213> 人工序列()
<400> 476
tttttttttc tactttttct gaggtttcct ctgg 34
<210> 477
<211> 36
<212> DNA
<213> 人工序列()
<400> 477
ttttttttgg gtaaatacat tcttcatacc aggacc 36
<210> 478
<211> 34
<212> DNA
<213> 人工序列()
<400> 478
tttttttttt gtctttattt gctttgtcaa gatc 34
<210> 479
<211> 32
<212> DNA
<213> 人工序列()
<400> 479
ttttttttta gagcgtgcag ataatgacaa gg 32
<210> 480
<211> 35
<212> DNA
<213> 人工序列()
<400> 480
ttttttttag aattaaacac acatcacata catac 35
<210> 481
<211> 35
<212> DNA
<213> 人工序列()
<400> 481
ttttttttaa atagtttaag atgagtcata tttgt 35
<210> 482
<211> 35
<212> DNA
<213> 人工序列()
<400> 482
tttttttttg agtcatattt gtgggttttc atttt 35
<210> 483
<211> 35
<212> DNA
<213> 人工序列()
<400> 483
tttttttttg tcagaatatc tataatgatc aggtt 35
<210> 484
<211> 34
<212> DNA
<213> 人工序列()
<400> 484
tttttttttc agagtcagtg gtgtcagaat atct 34
<210> 485
<211> 30
<212> DNA
<213> 人工序列()
<400> 485
tttttttttc tgacaccact gactctgatc 30
<210> 486
<211> 33
<212> DNA
<213> 人工序列()
<400> 486
tttttttttc tgacacaatg tcctattgcc att 33
<210> 487
<211> 28
<212> DNA
<213> 人工序列()
<400> 487
ttttttttag tggtctggtc actggaag 28
<210> 488
<211> 28
<212> DNA
<213> 人工序列()
<400> 488
ttttttttcg gaacattgcc cagcacta 28
<210> 489
<211> 28
<212> DNA
<213> 人工序列()
<400> 489
tttttttttc cagggtctcc aggaggta 28
<210> 490
<211> 27
<212> DNA
<213> 人工序列()
<400> 490
ttttttttct catctgcctc ggctcag 27
<210> 491
<211> 28
<212> DNA
<213> 人工序列()
<400> 491
ttttttttga gaccccagtc cactcaga 28
<210> 492
<211> 28
<212> DNA
<213> 人工序列()
<400> 492
ttttttttct gctccctttc aggtctgc 28
<210> 493
<211> 28
<212> DNA
<213> 人工序列()
<400> 493
ttttttttga tggtgagggc gaagtctc 28
<210> 494
<211> 26
<212> DNA
<213> 人工序列()
<400> 494
ttttttttgc ccacgaatgt gtctcg 26
<210> 495
<211> 27
<212> DNA
<213> 人工序列()
<400> 495
ttttttttgg gcatggactg gtctgca 27
<210> 496
<211> 28
<212> DNA
<213> 人工序列()
<400> 496
ttttttttag aagctgatgg ccttcacc 28
<210> 497
<211> 26
<212> DNA
<213> 人工序列()
<400> 497
tttttttttg cacgactcac caggtc 26
<210> 498
<211> 25
<212> DNA
<213> 人工序列()
<400> 498
ttttttttgg gctggtgacc tctcg 25
<210> 499
<211> 28
<212> DNA
<213> 人工序列()
<400> 499
tttttttttc atctcgatgg cagaggag 28
<210> 500
<211> 27
<212> DNA
<213> 人工序列()
<400> 500
ttttttttca ccaggcgctt ctcacag 27
<210> 501
<211> 29
<212> DNA
<213> 人工序列()
<400> 501
ttttttttct gcagaagccc tcaagacac 29
<210> 502
<211> 28
<212> DNA
<213> 人工序列()
<400> 502
ttttttttcg ctcctacgtg cttcctga 28
<210> 503
<211> 33
<212> DNA
<213> 人工序列()
<400> 503
tttttttttc tgagaaggaa gagtctttac aca 33
<210> 504
<211> 32
<212> DNA
<213> 人工序列()
<400> 504
ttttttttca aaccaggtga ataagctgaa cc 32
<210> 505
<211> 28
<212> DNA
<213> 人工序列()
<400> 505
ttttttttga gaactcgccg acatccac 28
<210> 506
<211> 30
<212> DNA
<213> 人工序列()
<400> 506
ttttttttgt agcctaaggt ccagagggtt 30
<210> 507
<211> 32
<212> DNA
<213> 人工序列()
<400> 507
ttttttttac acatgtacgt tagtgtcctc tc 32
<210> 508
<211> 31
<212> DNA
<213> 人工序列()
<400> 508
ttttttttga ttcagaagaa agtcacaggc t 31
<210> 509
<211> 31
<212> DNA
<213> 人工序列()
<400> 509
tttttttttt attgagcagc aagtgggaac c 31
<210> 510
<211> 31
<212> DNA
<213> 人工序列()
<400> 510
ttttttttcc ttatacttcc aggaatgatc a 31
<210> 511
<211> 30
<212> DNA
<213> 人工序列()
<400> 511
ttttttttct ctgagtgagc tcatttgcga 30
<210> 512
<211> 31
<212> DNA
<213> 人工序列()
<400> 512
ttttttttag tgacctaact cctctgtgtg c 31
<210> 513
<211> 28
<212> DNA
<213> 人工序列()
<400> 513
tttttttttt aggtcactgg cacatggc 28
<210> 514
<211> 25
<212> DNA
<213> 人工序列()
<400> 514
ttttttttcg tggccgtgta ccact 25
<210> 515
<211> 27
<212> DNA
<213> 人工序列()
<400> 515
ttttttttgc ctcagcccgt ccttcat 27
<210> 516
<211> 32
<212> DNA
<213> 人工序列()
<400> 516
ttttttttat taacaatgac attttagcct ca 32
<210> 517
<211> 29
<212> DNA
<213> 人工序列()
<400> 517
ttttttttcc cttcttgcga taccatggc 29
<210> 518
<211> 32
<212> DNA
<213> 人工序列()
<400> 518
tttttttttt tactggaaaa caactggaac at 32
<210> 519
<211> 28
<212> DNA
<213> 人工序列()
<400> 519
ttttttttgg ctgcctgtgg caaaaact 28
<210> 520
<211> 31
<212> DNA
<213> 人工序列()
<400> 520
tttttttttc tcatgtgtta cagcaagact c 31
<210> 521
<211> 31
<212> DNA
<213> 人工序列()
<400> 521
ttttttttca gtaaatcctc cacgttggat t 31
<210> 522
<211> 26
<212> DNA
<213> 人工序列()
<400> 522
ttttttttcc tctaccaggc cgcgat 26
<210> 523
<211> 29
<212> DNA
<213> 人工序列()
<400> 523
ttttttttca cttgctgcag gaatgaacg 29
<210> 524
<211> 32
<212> DNA
<213> 人工序列()
<400> 524
ttttttttaa tttctttctc tcgatgctgg ga 32
<210> 525
<211> 33
<212> DNA
<213> 人工序列()
<400> 525
ttttttttct tttcctttga ttccgccata gtt 33
<210> 526
<211> 33
<212> DNA
<213> 人工序列()
<400> 526
ttttttttgg aaataaagga aagttgagaa caa 33
<210> 527
<211> 33
<212> DNA
<213> 人工序列()
<400> 527
ttttttttgg gtcattttag catccctctc aaa 33
<210> 528
<211> 30
<212> DNA
<213> 人工序列()
<400> 528
ttttttttgg tcatcagtca tctacgccaa 30
<210> 529
<211> 31
<212> DNA
<213> 人工序列()
<400> 529
tttttttttt tgtacagagg atgatgcggt t 31
<210> 530
<211> 32
<212> DNA
<213> 人工序列()
<400> 530
ttttttttct cagctctttt ccctcttgga tt 32
<210> 531
<211> 30
<212> DNA
<213> 人工序列()
<400> 531
ttttttttca ctacttatcc cagaggcact 30
<210> 532
<211> 29
<212> DNA
<213> 人工序列()
<400> 532
tttttttttc ctctctgctt catgaccct 29
<210> 533
<211> 31
<212> DNA
<213> 人工序列()
<400> 533
ttttttttgg aagagcttct tcatcatgtt g 31
<210> 534
<211> 29
<212> DNA
<213> 人工序列()
<400> 534
ttttttttga tcctgaagag catggtcgt 29
<210> 535
<211> 32
<212> DNA
<213> 人工序列()
<400> 535
ttttttttcc tggttgtctg catagatgtt gt 32
<210> 536
<211> 30
<212> DNA
<213> 人工序列()
<400> 536
ttttttttga aaacctgtgc ccatttcagt 30
<210> 537
<211> 31
<212> DNA
<213> 人工序列()
<400> 537
ttttttttaa attaagggca aaggataaga c 31
<210> 538
<211> 29
<212> DNA
<213> 人工序列()
<400> 538
ttttttttat cagcttcgac gtgatccag 29
<210> 539
<211> 26
<212> DNA
<213> 人工序列()
<400> 539
ttttttttag cctgaccacc cgtgat 26
<210> 540
<211> 27
<212> DNA
<213> 人工序列()
<400> 540
ttttttttga gcatggcgtc ttcctgt 27
<210> 541
<211> 29
<212> DNA
<213> 人工序列()
<400> 541
tttttttttg tcgttgacat ggtgagact 29
<210> 542
<211> 28
<212> DNA
<213> 人工序列()
<400> 542
ttttttttgg tctgttgctg gttctgga 28
<210> 543
<211> 30
<212> DNA
<213> 人工序列()
<400> 543
ttttttttgg cactattgcc ttgagaagat 30
<210> 544
<211> 30
<212> DNA
<213> 人工序列()
<400> 544
ttttttttga caactgtctt gtcatggagt 30
<210> 545
<211> 29
<212> DNA
<213> 人工序列()
<400> 545
tttttttttt gatctcaaca gtggcttgg 29
<210> 546
<211> 29
<212> DNA
<213> 人工序列()
<400> 546
ttttttttag aggacatctc cacattcgg 29
<210> 547
<211> 29
<212> DNA
<213> 人工序列()
<400> 547
ttttttttca gttgtcatca gcctccttt 29
<210> 548
<211> 30
<212> DNA
<213> 人工序列()
<400> 548
ttttttttgt gcaggtactt tcacattccc 30
<210> 549
<211> 29
<212> DNA
<213> 人工序列()
<400> 549
tttttttttg tcctctggta ggttcccaa 29
<210> 550
<211> 28
<212> DNA
<213> 人工序列()
<400> 550
ttttttttgg ccttcgagat gagcaggt 28
<210> 551
<211> 29
<212> DNA
<213> 人工序列()
<400> 551
ttttttttgc ccacaacgac agtactgtg 29
<210> 552
<211> 32
<212> DNA
<213> 人工序列()
<400> 552
ttttttttgc ctatctgtgt ggctgacaag at 32
<210> 553
<211> 30
<212> DNA
<213> 人工序列()
<400> 553
ttttttttca ggttgaggta gtgacggatc 30
<210> 554
<211> 29
<212> DNA
<213> 人工序列()
<400> 554
ttttttttcc acactcatcg ctgttcagt 29
<210> 555
<211> 30
<212> DNA
<213> 人工序列()
<400> 555
ttttttttga taggcaccag tgggaattcc 30
<210> 556
<211> 30
<212> DNA
<213> 人工序列()
<400> 556
ttttttttgt gtgagcccca tcttctttga 30
<210> 557
<211> 32
<212> DNA
<213> 人工序列()
<400> 557
ttttttttca aggcaaaatg gaagaaaaga cc 32
<210> 558
<211> 30
<212> DNA
<213> 人工序列()
<400> 558
ttttttttca aacacacctt cgaagttcgg 30
<210> 559
<211> 26
<212> DNA
<213> 人工序列()
<400> 559
ttttttttcg agcaggaatc gctgga 26
<210> 560
<211> 26
<212> DNA
<213> 人工序列()
<400> 560
ttttttttgt ctaggtgcgc agcaac 26
<210> 561
<211> 29
<212> DNA
<213> 人工序列()
<400> 561
ttttttttcc gtgctctgct gagtacagg 29
<210> 562
<211> 31
<212> DNA
<213> 人工序列()
<400> 562
ttttttttcc atgagtgctt gtcgtgattg a 31
<210> 563
<211> 30
<212> DNA
<213> 人工序列()
<400> 563
ttttttttcc cttgaggaca agacctggag 30
<210> 564
<211> 26
<212> DNA
<213> 人工序列()
<400> 564
ttttttttcc cacaaagcgc tcttcg 26
<210> 565
<211> 30
<212> DNA
<213> 人工序列()
<400> 565
tttttttttc acagtgtcca gcacaaagac 30
<210> 566
<211> 29
<212> DNA
<213> 人工序列()
<400> 566
ttttttttgg gtgacggtct tgtttcctt 29
<210> 567
<211> 31
<212> DNA
<213> 人工序列()
<400> 567
ttttttttgc gtggtggtac aggtagatat g 31
<210> 568
<211> 30
<212> DNA
<213> 人工序列()
<400> 568
ttttttttag agacctttgc tcttgagcac 30
<210> 569
<211> 30
<212> DNA
<213> 人工序列()
<400> 569
ttttttttcc tggttccagg tagctgaact 30
<210> 570
<211> 31
<212> DNA
<213> 人工序列()
<400> 570
ttttttttcc cgattcttcc aggttccgtt a 31
<210> 571
<211> 28
<212> DNA
<213> 人工序列()
<400> 571
tttttttttg cttcccagcc tgaaaggt 28
<210> 572
<211> 27
<212> DNA
<213> 人工序列()
<400> 572
ttttttttca catcccgggc agaagtc 27
<210> 573
<211> 30
<212> DNA
<213> 人工序列()
<400> 573
ttttttttgg gcgggtttct ttcctccata 30
<210> 574
<211> 30
<212> DNA
<213> 人工序列()
<400> 574
ttttttttta tgagtattca gtgccagagg 30
<210> 575
<211> 29
<212> DNA
<213> 人工序列()
<400> 575
ttttttttca gctcagcgtt gatctcgtt 29
<210> 576
<211> 31
<212> DNA
<213> 人工序列()
<400> 576
ttttttttgc tttgtgtgtg taccacagac a 31
<210> 577
<211> 31
<212> DNA
<213> 人工序列()
<400> 577
ttttttttta gatcatggga aagccacctc a 31
<210> 578
<211> 29
<212> DNA
<213> 人工序列()
<400> 578
ttttttttcc cgtgtgttct acgtgaacc 29
<210> 579
<211> 27
<212> DNA
<213> 人工序列()
<400> 579
ttttttttcc ctcctccgct ttagcga 27
<210> 580
<211> 31
<212> DNA
<213> 人工序列()
<400> 580
ttttttttgt tccagtgtgt cctgtgatgt g 31
<210> 581
<211> 29
<212> DNA
<213> 人工序列()
<400> 581
ttttttttgc tggtctcgct gatctgaaa 29
<210> 582
<211> 30
<212> DNA
<213> 人工序列()
<400> 582
ttttttttct ggagtttcct gcccatcgta 30
<210> 583
<211> 29
<212> DNA
<213> 人工序列()
<400> 583
ttttttttta accctcccat cccagacct 29
<210> 584
<211> 28
<212> DNA
<213> 人工序列()
<400> 584
ttttttttgg gagcttcttg cgaagaac 28
<210> 585
<211> 26
<212> DNA
<213> 人工序列()
<400> 585
tttttttttc tgccacggaa ggtcca 26
<210> 586
<211> 29
<212> DNA
<213> 人工序列()
<400> 586
ttttttttca agaagaagtg gcagctgca 29
<210> 587
<211> 27
<212> DNA
<213> 人工序列()
<400> 587
ttttttttcc ctctgccgac tccagac 27
<210> 588
<211> 27
<212> DNA
<213> 人工序列()
<400> 588
ttttttttgg cgggcattcc catctca 27
<210> 589
<211> 28
<212> DNA
<213> 人工序列()
<400> 589
ttttttttct gtgcagaccc ctcagaga 28
<210> 590
<211> 28
<212> DNA
<213> 人工序列()
<400> 590
ttttttttca gcccctgtca ctgtgaag 28
<210> 591
<211> 29
<212> DNA
<213> 人工序列()
<400> 591
tttttttttc tcccaaagaa ctcgcttcc 29
<210> 592
<211> 28
<212> DNA
<213> 人工序列()
<400> 592
ttttttttgc agcccgagat cctgagat 28
<210> 593
<211> 32
<212> DNA
<213> 人工序列()
<400> 593
ttttttttga acagaagctt cactacagca ca 32
<210> 594
<211> 32
<212> DNA
<213> 人工序列()
<400> 594
ttttttttaa ctgctggaga agaatgatgt ct 32
<210> 595
<211> 30
<212> DNA
<213> 人工序列()
<400> 595
ttttttttgg gtgaagagct cactgatctt 30
<210> 596
<211> 32
<212> DNA
<213> 人工序列()
<400> 596
ttttttttgg gctaaaaact gtgcagttag ac 32
<210> 597
<211> 32
<212> DNA
<213> 人工序列()
<400> 597
ttttttttat cagagagaga cccttgtcta ac 32
<210> 598
<211> 33
<212> DNA
<213> 人工序列()
<400> 598
ttttttttca gattctggat tgggactact aca 33
<210> 599
<211> 32
<212> DNA
<213> 人工序列()
<400> 599
ttttttttgg gatggtgatg atcttctgga tg 32
<210> 600
<211> 33
<212> DNA
<213> 人工序列()
<400> 600
tttttttttg agaggattaa ataagacaca gtg 33
<210> 601
<211> 33
<212> DNA
<213> 人工序列()
<400> 601
ttttttttat tctgctctgt ctagctttcc ttg 33
<210> 602
<211> 31
<212> DNA
<213> 人工序列()
<400> 602
ttttttttga ggaagcactt tctccggaaa t 31
<210> 603
<211> 31
<212> DNA
<213> 人工序列()
<400> 603
ttttttttct ggcactcact gctcgaatat c 31
<210> 604
<211> 32
<212> DNA
<213> 人工序列()
<400> 604
ttttttttag gatcagattt tgggtgattt tc 32
<210> 605
<211> 26
<212> DNA
<213> 人工序列()
<400> 605
ttttttttga gccctcacct gtccgt 26
<210> 606
<211> 29
<212> DNA
<213> 人工序列()
<400> 606
ttttttttcc gagttcctgg gagaccaga 29
<210> 607
<211> 30
<212> DNA
<213> 人工序列()
<400> 607
ttttttttag atgatgtagc ggcaactcag 30
<210> 608
<211> 32
<212> DNA
<213> 人工序列()
<400> 608
ttttttttaa catgcctgac tctgagctat tc 32
<210> 609
<211> 32
<212> DNA
<213> 人工序列()
<400> 609
ttttttttgt agacttctgc tccccgtaat ct 32
<210> 610
<211> 33
<212> DNA
<213> 人工序列()
<400> 610
ttttttttcc ttgatttctg cagtgtttta ccc 33
<210> 611
<211> 32
<212> DNA
<213> 人工序列()
<400> 611
ttttttttgt tggctgccta gagaaagaca at 32
<210> 612
<211> 35
<212> DNA
<213> 人工序列()
<400> 612
ttttttttaa agtattgcca cacaggcata ttaga 35
<210> 613
<211> 31
<212> DNA
<213> 人工序列()
<400> 613
ttttttttct tcatccttca tccctcagag c 31
<210> 614
<211> 34
<212> DNA
<213> 人工序列()
<400> 614
tttttttttg cagctgatta agatcttcca atcc 34
<210> 615
<211> 31
<212> DNA
<213> 人工序列()
<400> 615
ttttttttta cagagccata cacctcttcc a 31
<210> 616
<211> 32
<212> DNA
<213> 人工序列()
<400> 616
ttttttttgg tatgctgtgt tcaatgaaga cg 32
<210> 617
<211> 26
<212> DNA
<213> 人工序列()
<400> 617
ttttttttcg cggcgtttga cctcaa 26
<210> 618
<211> 29
<212> DNA
<213> 人工序列()
<400> 618
ttttttttga caggtggagg gttggaaag 29
<210> 619
<211> 33
<212> DNA
<213> 人工序列()
<400> 619
ttttttttcc aacctccttt ctgggctaaa tta 33
<210> 620
<211> 30
<212> DNA
<213> 人工序列()
<400> 620
tttttttttt tttgaggttg atgggcccta 30
<210> 621
<211> 28
<212> DNA
<213> 人工序列()
<400> 621
ttttttttgg aggctggaag aatcatgg 28
<210> 622
<211> 28
<212> DNA
<213> 人工序列()
<400> 622
ttttttttgg gccatcatga gtgaagct 28
<210> 623
<211> 28
<212> DNA
<213> 人工序列()
<400> 623
ttttttttgt gacatcaggg cactgacg 28
<210> 624
<211> 30
<212> DNA
<213> 人工序列()
<400> 624
ttttttttcc caacagcttc ccagaaaatt 30
<210> 625
<211> 28
<212> DNA
<213> 人工序列()
<400> 625
ttttttttcc tgggtaggag atggtcac 28
<210> 626
<211> 29
<212> DNA
<213> 人工序列()
<400> 626
ttttttttca ctgggtgaaa aggaaaggg 29
<210> 627
<211> 28
<212> DNA
<213> 人工序列()
<400> 627
tttttttttt ccttcctgcc catgcttg 28
<210> 628
<211> 26
<212> DNA
<213> 人工序列()
<400> 628
ttttttttct ctcagggctc gctggt 26
<210> 629
<211> 27
<212> DNA
<213> 人工序列()
<400> 629
ttttttttcg gctccccttc tgcactc 27
<210> 630
<211> 28
<212> DNA
<213> 人工序列()
<400> 630
ttttttttct ctgatacccc ctggagga 28
<210> 631
<211> 33
<212> DNA
<213> 人工序列()
<400> 631
ttttttttct ccctccaaca ttccttgaat cag 33
<210> 632
<211> 32
<212> DNA
<213> 人工序列()
<400> 632
ttttttttca agtgcatcct gaactccttc ta 32
<210> 633
<211> 29
<212> DNA
<213> 人工序列()
<400> 633
ttttttttct accccttgcg catgacata 29
<210> 634
<211> 32
<212> DNA
<213> 人工序列()
<400> 634
ttttttttca tgttcatgtg cttctcaggt gt 32
<210> 635
<211> 32
<212> DNA
<213> 人工序列()
<400> 635
tttttttttc atacagcacc tccatgttct tg 32
<210> 636
<211> 35
<212> DNA
<213> 人工序列()
<400> 636
ttttttttac taaaaacctg ggctattgac tttgt 35
<210> 637
<211> 30
<212> DNA
<213> 人工序列()
<400> 637
ttttttttcc acttcatgag ccgactgaaa 30
<210> 638
<211> 31
<212> DNA
<213> 人工序列()
<400> 638
ttttttttgg gaaaactcct tctacgtgga c 31
<210> 639
<211> 30
<212> DNA
<213> 人工序列()
<400> 639
ttttttttgt ggagcccttt gaactcgtaa 30
<210> 640
<211> 31
<212> DNA
<213> 人工序列()
<400> 640
tttttttttg cttagattac tgccggaaag c 31
<210> 641
<211> 34
<212> DNA
<213> 人工序列()
<400> 641
ttttttttcc ttggtgatgt ggatcttctt gtag 34
<210> 642
<211> 31
<212> DNA
<213> 人工序列()
<400> 642
ttttttttta gcagtgtatc tgagctgttg c 31
<210> 643
<211> 30
<212> DNA
<213> 人工序列()
<400> 643
ttttttttga gcaggagcca catctttaca 30
<210> 644
<211> 29
<212> DNA
<213> 人工序列()
<400> 644
ttttttttat accatcggat ccagcacca 29
<210> 645
<211> 26
<212> DNA
<213> 人工序列()
<400> 645
tttttttttt cctcgcggga cagttc 26
<210> 646
<211> 30
<212> DNA
<213> 人工序列()
<400> 646
ttttttttgt gtgtctgtgc ctccttttga 30
<210> 647
<211> 27
<212> DNA
<213> 人工序列()
<400> 647
ttttttttga cactcaccca cccgttt 27
<210> 648
<211> 27
<212> DNA
<213> 人工序列()
<400> 648
ttttttttgc cctctgccat ggtggac 27
<210> 649
<211> 32
<212> DNA
<213> 人工序列()
<400> 649
ttttttttgc agtttgctcc aggcttattg aa 32
<210> 650
<211> 31
<212> DNA
<213> 人工序列()
<400> 650
ttttttttat gtaccccaac atcatcctga c 31
<210> 651
<211> 30
<212> DNA
<213> 人工序列()
<400> 651
ttttttttcg actctgacac gggaagtaaa 30
<210> 652
<211> 33
<212> DNA
<213> 人工序列()
<400> 652
tttttttttc tctgcaggtg tgtgatgaga tta 33
<210> 653
<211> 31
<212> DNA
<213> 人工序列()
<400> 653
tttttttttg gtagatgagt ggacactcga t 31
<210> 654
<211> 34
<212> DNA
<213> 人工序列()
<400> 654
ttttttttca gctttttcct ctcctgaatg tcta 34
<210> 655
<211> 32
<212> DNA
<213> 人工序列()
<400> 655
ttttttttca caataaacgt gctgctgaaa ga 32
<210> 656
<211> 32
<212> DNA
<213> 人工序列()
<400> 656
ttttttttct tgaggaagag gagaaagtgc ct 32
<210> 657
<211> 32
<212> DNA
<213> 人工序列()
<400> 657
ttttttttcc tccctgatgg ttacctcttc aa 32
<210> 658
<211> 27
<212> DNA
<213> 人工序列()
<400> 658
ttttttttct gaccccgtcg tctcact 27
<210> 659
<211> 28
<212> DNA
<213> 人工序列()
<400> 659
tttttttttc aaaggcggca ggattcta 28
<210> 660
<211> 28
<212> DNA
<213> 人工序列()
<400> 660
ttttttttgg agctttctcg ggcacaac 28
<210> 661
<211> 30
<212> DNA
<213> 人工序列()
<400> 661
ttttttttgg tcctaccaca gcacaagagt 30
<210> 662
<211> 30
<212> DNA
<213> 人工序列()
<400> 662
ttttttttag ttcaataagc tgacggacga 30
<210> 663
<211> 29
<212> DNA
<213> 人工序列()
<400> 663
ttttttttcc cgacgtaggt ctcagagtc 29
<210> 664
<211> 31
<212> DNA
<213> 人工序列()
<400> 664
ttttttttct ggaagccttg gtttctcttg c 31
<210> 665
<211> 30
<212> DNA
<213> 人工序列()
<400> 665
ttttttttgg aagatgatgt tggcgtggaa 30
<210> 666
<211> 33
<212> DNA
<213> 人工序列()
<400> 666
tttttttttc ctttcacact gaagttcagc tta 33
<210> 667
<211> 31
<212> DNA
<213> 人工序列()
<400> 667
tttttttttt cagctccagt gcatttggaa t 31
<210> 668
<211> 31
<212> DNA
<213> 人工序列()
<400> 668
ttttttttca gatgctgtcg ccacttacta c 31
<210> 669
<211> 34
<212> DNA
<213> 人工序列()
<400> 669
ttttttttta atggtgcaca gagcaaagat gaat 34
<210> 670
<211> 32
<212> DNA
<213> 人工序列()
<400> 670
ttttttttga ccctgggctc ttgatttttg at 32
<210> 671
<211> 27
<212> DNA
<213> 人工序列()
<400> 671
ttttttttcc gggatgtggc tcacatg 27
<210> 672
<211> 28
<212> DNA
<213> 人工序列()
<400> 672
ttttttttcc aaggccaagc taggctat 28
<210> 673
<211> 25
<212> DNA
<213> 人工序列()
<400> 673
tttttttttg ctccgtggcc atccg 25
<210> 674
<211> 31
<212> DNA
<213> 人工序列()
<400> 674
ttttttttgg gctgcatgtt agaatcatcc t 31
<210> 675
<211> 30
<212> DNA
<213> 人工序列()
<400> 675
tttttttttc ctcccatgag atgtggtgac 30
<210> 676
<211> 31
<212> DNA
<213> 人工序列()
<400> 676
ttttttttag gagataggct tccagaagga c 31
<210> 677
<211> 27
<212> DNA
<213> 人工序列()
<400> 677
ttttttttac ctgaggcagt ccatgtg 27
<210> 678
<211> 27
<212> DNA
<213> 人工序列()
<400> 678
ttttttttgg gcattagagc ctgacct 27
<210> 679
<211> 29
<212> DNA
<213> 人工序列()
<400> 679
ttttttttgc cacctcctaa gtcgacatg 29
<210> 680
<211> 31
<212> DNA
<213> 人工序列()
<400> 680
ttttttttga tccaaaggtg gtttgaacac g 31
<210> 681
<211> 36
<212> DNA
<213> 人工序列()
<400> 681
ttttttttcc agttactcat agagaagaca cagact 36
<210> 682
<211> 36
<212> DNA
<213> 人工序列()
<400> 682
tttttttttt ggaatagctt gaagaagaga aagagc 36
<210> 683
<211> 30
<212> DNA
<213> 人工序列()
<400> 683
ttttttttgc tgcaattctg atctgacgga 30
<210> 684
<211> 34
<212> DNA
<213> 人工序列()
<400> 684
ttttttttat tgaagatttt gagttcaccc ccaa 34
<210> 685
<211> 35
<212> DNA
<213> 人工序列()
<400> 685
ttttttttgg tagtttccca agtgatacct cctta 35
<210> 686
<211> 34
<212> DNA
<213> 人工序列()
<400> 686
ttttttttct ctgacttgtg ctgattgcta atga 34
<210> 687
<211> 32
<212> DNA
<213> 人工序列()
<400> 687
tttttttttc tgaaacaatc tccctgttgg tg 32
<210> 688
<211> 34
<212> DNA
<213> 人工序列()
<400> 688
ttttttttag gaagcttaaa gcactttcac attg 34
<210> 689
<211> 37
<212> DNA
<213> 人工序列()
<400> 689
ttttttttat tcctggacta actcattatt cactcaa 37
<210> 690
<211> 32
<212> DNA
<213> 人工序列()
<400> 690
ttttttttct gatgctgaga cagaccagat ta 32
<210> 691
<211> 32
<212> DNA
<213> 人工序列()
<400> 691
tttttttttg gccatcgatc atgtaggaaa tc 32
<210> 692
<211> 35
<212> DNA
<213> 人工序列()
<400> 692
ttttttttgg agtttagagc ttggctttat gctta 35
<210> 693
<211> 32
<212> DNA
<213> 人工序列()
<400> 693
ttttttttca gtttggtcgt ctcaatgtca aa 32
<210> 694
<211> 33
<212> DNA
<213> 人工序列()
<400> 694
ttttttttca gctctagagc cttttgactc ttt 33
<210> 695
<211> 36
<212> DNA
<213> 人工序列()
<400> 695
ttttttttgc actgaagaat attctctcca gaaaac 36
<210> 696
<211> 33
<212> DNA
<213> 人工序列()
<400> 696
ttttttttct agttagcaca ctgtgtgttt tgc 33
<210> 697
<211> 32
<212> DNA
<213> 人工序列()
<400> 697
ttttttttag caaaacttac aggtcgttca ac 32
<210> 698
<211> 34
<212> DNA
<213> 人工序列()
<400> 698
ttttttttag atgatcatta tgggtgaatc caca 34
<210> 699
<211> 32
<212> DNA
<213> 人工序列()
<400> 699
tttttttttc atctcctggc tgttaggaaa tt 32
<210> 700
<211> 36
<212> DNA
<213> 人工序列()
<400> 700
ttttttttac tgatgaagag gaaacctcta agaaga 36
<210> 701
<211> 27
<212> DNA
<213> 人工序列()
<400> 701
ttttttttca tcgtactcgc gcatgtc 27
<210> 702
<211> 31
<212> DNA
<213> 人工序列()
<400> 702
ttttttttcc tactgagttg gaactctggt c 31
<210> 703
<211> 33
<212> DNA
<213> 人工序列()
<400> 703
ttttttttgt gttcctgtct cctatccatc ttg 33
<210> 704
<211> 32
<212> DNA
<213> 人工序列()
<400> 704
ttttttttac actgtggagg atcttgtcaa ag 32
<210> 705
<211> 33
<212> DNA
<213> 人工序列()
<400> 705
ttttttttca agaccaaagt ttacctggaa agc 33
<210> 706
<211> 32
<212> DNA
<213> 人工序列()
<400> 706
ttttttttca aatcacttgg tgggtttgaa gc 32
<210> 707
<211> 32
<212> DNA
<213> 人工序列()
<400> 707
ttttttttgt ggaaggacag cctgatgtaa tt 32
<210> 708
<211> 32
<212> DNA
<213> 人工序列()
<400> 708
ttttttttct tgaagtcgcc aactctttga ct 32
<210> 709
<211> 34
<212> DNA
<213> 人工序列()
<400> 709
ttttttttaa caatgtagac tctggcctca ttta 34
<210> 710
<211> 35
<212> DNA
<213> 人工序列()
<400> 710
ttttttttga aagccttttc attctgatcc tgatt 35
<210> 711
<211> 34
<212> DNA
<213> 人工序列()
<400> 711
ttttttttag aaaagatgaa acttctcgct caca 34
<210> 712
<211> 32
<212> DNA
<213> 人工序列()
<400> 712
ttttttttga ccagaaaggt gagtgtgttt ca 32
<210> 713
<211> 31
<212> DNA
<213> 人工序列()
<400> 713
ttttttttag aatgacacac aggtcgtctg a 31
<210> 714
<211> 34
<212> DNA
<213> 人工序列()
<400> 714
ttttttttgc aagcaatgtg ttttcacttt tctc 34
<210> 715
<211> 32
<212> DNA
<213> 人工序列()
<400> 715
ttttttttca gtcacagagc tacatgaaca cc 32
<210> 716
<211> 35
<212> DNA
<213> 人工序列()
<400> 716
ttttttttac ccataaaagt gggttttagc ttgtc 35
<210> 717
<211> 33
<212> DNA
<213> 人工序列()
<400> 717
tttttttttt gtgtctgtgt tgactgattc tct 33
<210> 718
<211> 34
<212> DNA
<213> 人工序列()
<400> 718
ttttttttct aactgtgtag aggatggtct tgtg 34
<210> 719
<211> 32
<212> DNA
<213> 人工序列()
<400> 719
ttttttttct tcacatctcc cacctgattc ac 32
<210> 720
<211> 31
<212> DNA
<213> 人工序列()
<400> 720
tttttttttg agaagacagg ctggctcatt a 31
<210> 721
<211> 31
<212> DNA
<213> 人工序列()
<400> 721
ttttttttgg agaaggacct agtgcttaca g 31
<210> 722
<211> 30
<212> DNA
<213> 人工序列()
<400> 722
tttttttttc tttcactcag ggatgatggc 30
<210> 723
<211> 33
<212> DNA
<213> 人工序列()
<400> 723
ttttttttca aaaccaaacc gcaaatccat ctt 33
<210> 724
<211> 33
<212> DNA
<213> 人工序列()
<400> 724
ttttttttag cagcaggtgg cattacaaat taa 33
<210> 725
<211> 25
<212> DNA
<213> 人工序列()
<400> 725
ttttttttcc ccatggcacc ctccg 25
<210> 726
<211> 26
<212> DNA
<213> 人工序列()
<400> 726
ttttttttgt gggagcgcgc caaatt 26
<210> 727
<211> 28
<212> DNA
<213> 人工序列()
<400> 727
tttttttttg ctccatttgg ggacctgt 28
<210> 728
<211> 30
<212> DNA
<213> 人工序列()
<400> 728
ttttttttaa gacgaggtca gacttgttgt 30
<210> 729
<211> 33
<212> DNA
<213> 人工序列()
<400> 729
ttttttttcc atacagtgac tacggtcagt tct 33
<210> 730
<211> 32
<212> DNA
<213> 人工序列()
<400> 730
ttttttttga tgaagaaact gatcacccac at 32
<210> 731
<211> 27
<212> DNA
<213> 人工序列()
<400> 731
ttttttttag ttccaggggt ggtccat 27
<210> 732
<211> 30
<212> DNA
<213> 人工序列()
<400> 732
tttttttttc tgaagagctg ccattctgac 30
<210> 733
<211> 28
<212> DNA
<213> 人工序列()
<400> 733
ttttttttgc tgagaccttc ctcgactg 28
<210> 734
<211> 29
<212> DNA
<213> 人工序列()
<400> 734
ttttttttcc aggacgtcga tgaactgat 29
<210> 735
<211> 28
<212> DNA
<213> 人工序列()
<400> 735
ttttttttgg ctgtcgctca gcatgaag 28
<210> 736
<211> 31
<212> DNA
<213> 人工序列()
<400> 736
ttttttttaa acgtgtttgt caagtcatgg a 31
<210> 737
<211> 31
<212> DNA
<213> 人工序列()
<400> 737
tttttttttg aacactaaac acactcacgc t 31
<210> 738
<211> 32
<212> DNA
<213> 人工序列()
<400> 738
tttttttttg cagaaatgga aatcattggt ca 32
<210> 739
<211> 33
<212> DNA
<213> 人工序列()
<400> 739
tttttttttg ctcatgtgca ttaaccaata ctc 33
<210> 740
<211> 28
<212> DNA
<213> 人工序列()
<400> 740
ttttttttgt cagcgtgcag cagttatt 28
<210> 741
<211> 31
<212> DNA
<213> 人工序列()
<400> 741
ttttttttgc agttcaactt ctgtaacacc a 31
<210> 742
<211> 31
<212> DNA
<213> 人工序列()
<400> 742
tttttttttg ctgatcttca tcaaaaggtt c 31
<210> 743
<211> 75
<212> DNA
<213> 人工序列()
<400> 743
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagctaagg 60
taacgatcgg aaaaa 75
<210> 744
<211> 66
<212> DNA
<213> 人工序列()
<400> 744
atcaccgacg caagcctcag tagcgactaa ggtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 745
<211> 75
<212> DNA
<213> 人工序列()
<400> 745
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagttacaa 60
cctcgatcgg aaaaa 75
<210> 746
<211> 66
<212> DNA
<213> 人工序列()
<400> 746
atcaccgacg caagcctcag tagcgattac agtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 747
<211> 77
<212> DNA
<213> 人工序列()
<400> 747
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagcctgcc 60
attcgcgatc ggaaaaa 77
<210> 748
<211> 66
<212> DNA
<213> 人工序列()
<400> 748
atcaccgacg caagcctcag tagcgacctg cgtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 749
<211> 77
<212> DNA
<213> 人工序列()
<400> 749
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagtggagg 60
acggacgatc ggaaaaa 77
<210> 750
<211> 66
<212> DNA
<213> 人工序列()
<400> 750
atcaccgacg caagcctcag tagcgatgga ggtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 751
<211> 75
<212> DNA
<213> 人工序列()
<400> 751
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagtgagcg 60
gaacgatcgg aaaaa 75
<210> 752
<211> 66
<212> DNA
<213> 人工序列()
<400> 752
atcaccgacg caagcctcag tagcgatgag cgtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 753
<211> 76
<212> DNA
<213> 人工序列()
<400> 753
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagccttag 60
agttcgatcg gaaaaa 76
<210> 754
<211> 66
<212> DNA
<213> 人工序列()
<400> 754
atcaccgacg caagcctcag tagcgacctt agtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 755
<211> 75
<212> DNA
<213> 人工序列()
<400> 755
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagtcctcg 60
aatcgatcgg aaaaa 75
<210> 756
<211> 66
<212> DNA
<213> 人工序列()
<400> 756
atcaccgacg caagcctcag tagcgatcct cgtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 757
<211> 75
<212> DNA
<213> 人工序列()
<400> 757
tccgatcgca agcctcagta gcgaccatct catccctgcg tgtctccgac tcagaacctc 60
attcgatcgg aaaaa 75
<210> 758
<211> 66
<212> DNA
<213> 人工序列()
<400> 758
atcaccgacg caagcctcag tagcgaaacc tgtctcagcc tctctatggg cagtcggtga 60
taaaaa 66
<210> 759
<211> 17
<212> DNA
<213> 人工序列()
<400> 759
tcgctactga ggcttgc 17

Claims (9)

1.一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，该文库构建方法使用的引物序列如SEQ ID NO.1-759所示。
2.根据权利要求1所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，包括如下步骤：
(1)使用引物序列SEQ ID NO.1-759对待测样本进行多重PCR扩增获得文库；
(2)文库的纯化。
3.根据权利要求2所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，所述待测样本为手术切除的新鲜病理组织，甲醛固定石蜡包埋病例组织，石蜡切片，全血，血浆，血清，胸腔积液中的一种。
4.根据权利要求2所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，所述步骤(1)中PCR扩增程序如下表所示。
Figure FDA0002711995790000011
5.根据权利要求2所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，所述步骤(1)中PCR扩增反应体系如下表所示。
序号 物料 物料浓度 用量(μL) 1 RingCapbuffer 10× 2 2 MgCl<sub>2</sub> 25mM 4 3 dNTPs 10μM 2 4 DNA富集反应引物MIX 50μM 5 5 H<sub>2</sub>O 纯化水 5.9 6 RingCap-Taq酶 5U/ul 0.5 7 Ion-BCXX-F 50μM 0.2 8 Ion-BCXX-R 50μM 0.2 9 C-Primer 50μM 0.2 10 DNA 2ng/ul 5 总体积 25
6.根据权利要求5所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，DNA富集反应引物MIX按照下表配制。
Figure FDA0002711995790000021
Figure FDA0002711995790000031
Figure FDA0002711995790000041
Figure FDA0002711995790000051
Figure FDA0002711995790000061
Figure FDA0002711995790000071
Figure FDA0002711995790000081
Figure FDA0002711995790000091
Figure FDA0002711995790000101
Figure FDA0002711995790000111
Figure FDA0002711995790000121
Figure FDA0002711995790000131
Figure FDA0002711995790000141
Figure FDA0002711995790000151
Figure FDA0002711995790000161
7.根据权利要求2所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，所述步骤(2)中文库进行两次纯化。
8.根据权利要求1-7中任一项所述的基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法，其特征在于，子宫内膜癌相关基因为MSH2、PMS2、MLH1、MSH6、EPCAM、TP53、POLE和PTEN。
9.根据权利要求1-7中任一项所述的文库构建方法所构建的测序文库。
CN202011059870.8A 2020-09-30 2020-09-30 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法 Active CN112064122B (zh)

Priority Applications (3)

Application Number Priority Date Filing Date Title
CN202011059870.8A CN112064122B (zh) 2020-09-30 2020-09-30 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法
US17/430,315 US20220307016A1 (en) 2020-09-30 2020-10-30 Library construction method for detecting endometrial cancer-related gene mutations based on high-throughput sequencing
PCT/CN2020/125277 WO2022067938A1 (zh) 2020-09-30 2020-10-30 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202011059870.8A CN112064122B (zh) 2020-09-30 2020-09-30 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法

Publications (2)

Publication Number Publication Date
CN112064122A true CN112064122A (zh) 2020-12-11
CN112064122B CN112064122B (zh) 2021-06-04

Family

ID=73684234

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202011059870.8A Active CN112064122B (zh) 2020-09-30 2020-09-30 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法

Country Status (3)

Country Link
US (1) US20220307016A1 (zh)
CN (1) CN112064122B (zh)
WO (1) WO2022067938A1 (zh)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN114438210A (zh) * 2022-03-29 2022-05-06 复旦大学附属妇产科医院 一种基于高通量测序子宫内膜癌分子分型的文库构建方法

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN105332063A (zh) * 2015-08-13 2016-02-17 厦门飞朔生物技术有限公司 一种单管高通量测序文库的构建方法
WO2016141169A1 (en) * 2015-03-03 2016-09-09 Caris Mpi, Inc. Molecular profiling for cancer
CN106755501A (zh) * 2017-01-25 2017-05-31 广州燃石医学检验所有限公司 一种基于二代测序的同时检测微卫星位点稳定性和基因组变化的方法
CN107312822A (zh) * 2016-04-26 2017-11-03 厦门飞朔生物技术有限公司 一种用于高通量测序检测的肿瘤基因变异文库的构建方法及其应用
CN109182525A (zh) * 2018-09-29 2019-01-11 广州燃石医学检验所有限公司 一种微卫星生物标志物组合、检测试剂盒及其用途

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN106591957A (zh) * 2016-11-10 2017-04-26 复旦大学附属中山医院 一种胃肠道间质瘤多基因变异文库的构建方法及应用
CN106939337B (zh) * 2017-03-21 2020-06-05 重庆市肿瘤研究所 激素受体阳性乳腺癌复发监测基因突变文库的构建方法

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2016141169A1 (en) * 2015-03-03 2016-09-09 Caris Mpi, Inc. Molecular profiling for cancer
CN105332063A (zh) * 2015-08-13 2016-02-17 厦门飞朔生物技术有限公司 一种单管高通量测序文库的构建方法
CN107312822A (zh) * 2016-04-26 2017-11-03 厦门飞朔生物技术有限公司 一种用于高通量测序检测的肿瘤基因变异文库的构建方法及其应用
CN106755501A (zh) * 2017-01-25 2017-05-31 广州燃石医学检验所有限公司 一种基于二代测序的同时检测微卫星位点稳定性和基因组变化的方法
CN109182525A (zh) * 2018-09-29 2019-01-11 广州燃石医学检验所有限公司 一种微卫星生物标志物组合、检测试剂盒及其用途

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
ASHISH KUMAR SINGH等: "Targeted sequencing of genes associated with the mismatch repair pathway in patients with endometrial cancer", 《PLOS ONE》 *
戴一博等: "子宫内膜癌DNA错配修复基因异常的相关研究进展", 《中华妇产科杂志》 *

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN114438210A (zh) * 2022-03-29 2022-05-06 复旦大学附属妇产科医院 一种基于高通量测序子宫内膜癌分子分型的文库构建方法

Also Published As

Publication number Publication date
US20220307016A1 (en) 2022-09-29
WO2022067938A1 (zh) 2022-04-07
CN112064122B (zh) 2021-06-04

Similar Documents

Publication Publication Date Title
CN105624272B (zh) 基因组预定区域核酸测序文库的构建方法及装置
EP2663652B1 (en) High resolution melting analysis as a prescreening tool
JP2014519310A (ja) Ｄｎａメチル化のデジタル配列分析
CN114277135B (zh) 胃癌***转移相关的甲基化生物标记物及其组合和检测试剂盒
CN108070658B (zh) 检测msi的非诊断方法
WO2018147438A1 (ja) Ｈｌａ遺伝子のｐｃｒプライマーセット及びそれを用いたシークエンス法
CN106399546B (zh) 高通量测序检测人循环肿瘤dna egfr基因的捕获探针及试剂盒
CN114085903B (zh) 检测线粒体3243a＞g突变的引物对探针组合产品及其试剂盒与检测方法
CN110885883B (zh) Dna参照标准及其应用
CN113278611A (zh) 捕获测序探针及其用途
CN110846408A (zh) 用于检测ttn基因突变的引物组合及其应用
CN110846409A (zh) 用于检测tnni3k基因突变的引物组合及其应用
CN112064122B (zh) 一种基于高通量测序检测子宫内膜癌相关基因突变的文库构建方法
CN110564861A (zh) 人类Y染色体STR基因座和InDel位点的荧光标记复合扩增试剂盒及其应用
KR101890350B1 (ko) 돼지의 육질 예측용 snp 마커 및 이의 용도
CN114438210B (zh) 一种基于高通量测序子宫内膜癌分子分型的文库构建方法
US20030113723A1 (en) Method for evaluating microsatellite instability in a tumor sample
TWI567202B (zh) 檢測酒精代謝基因之方法及套組
CN112143815B (zh) 一种用于检测人fgfr2基因融合突变的核酸组合物、试剂盒及检测方法
CN112322722B (zh) 检测16p11.2微缺失的引物探针组合物、试剂盒及其应用
CN106811537A (zh) 一种检测表皮生长因子受体基因t790m低频突变引物及其应用
WO2020096247A1 (ko) 유방암 조직 내 세포 유래 돌연변이를 검출하기 위한 프로브 제조 및 검출 방법
CN107267645B (zh) 用于检测mthfr基因多态性的引物对、探针及试剂盒
CA3029402C (en) Method for producing dna probe and method for analyzing genomic dna using the dna probe
CN111411149A (zh) 一种检测肥厚型心肌病基因突变的引物组、试剂盒和方法

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant