From 7d739c607478e15516c1be8730aaffb184d63864 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 31 Jan 2024 18:06:38 +0100 Subject: [PATCH 01/52] First try at intervaltree --- src/main.rs | 173 +++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 124 insertions(+), 49 deletions(-) diff --git a/src/main.rs b/src/main.rs index d2ffcd3..b4850fc 100755 --- a/src/main.rs +++ b/src/main.rs @@ -1,12 +1,54 @@ use bam::record::cigar::Operation; use bam::record::tags::TagValue; use bam::BamReader; +use feature::Feature; +use intervaltree::IntervalTree; +use interval::Interval; +use std::cmp::{max, min}; use std::collections::HashMap; use std::fs::File; use std::io::{BufRead, BufReader, Write}; use structopt::StructOpt; +mod feature; +mod intervaltree; +mod interval; +mod node; + +use node::Node; + fn main() { + // test intervaltree + let mut tree = IntervalTree::new(); + tree.insert(0, 10, Some(Feature { + name: "test".to_string(), + chr: "chr1".to_string(), + start: 0, + end: 10, + start_sorted_index: 0, + end_sorted_index: 0 + })); + + let interval = Interval::new(0, 10, Some(Feature { + name: "test".to_string(), + chr: "chr1".to_string(), + start: 0, + end: 10, + start_sorted_index: 0, + end_sorted_index: 0 + })); + + println!("{:?}",interval); + let args = Args::from_args(); + + // test node + read_gtf(&args.gtf, args.t.as_str()); + + // exit(1) to prevent the rest of the program from running + std::process::exit(1); + + + // Command line arguments let args = Args::from_args(); @@ -27,6 +69,14 @@ fn main() { // Read the gtf file let gtf_end_sorted = read_gtf(&args.gtf, args.t.as_str()); + if args.export_feature_map.is_some() { + let mut file = File::create(args.export_feature_map.clone().unwrap()).expect("Unable to create file"); + for (chr, features) in gtf_end_sorted.iter() { + for feature in features.0.iter() { + file.write_all(format!("{}\t{}\t{}\t{}\t{}\t{}\n", chr, feature.start, feature.end, feature.name, feature.start_sorted_index, feature.end_sorted_index).as_bytes()).expect("Unable to write data"); + } + } + } let mut counts = prepare_count_hashmap(>f_end_sorted); @@ -135,19 +185,14 @@ struct Args { help = "Filename to output the counts to instead of stdout." )] counts_output: Option, -} - -// Struct to store the features -#[derive(Debug, Eq, PartialEq, Hash, Clone)] -struct Feature { - //type_: String, - name: String, - chr: String, - start: u32, - end: u32, - start_sorted_index: usize, - end_sorted_index: usize, + // Export feature map + #[structopt( + short = "f", + long = "export_feature_map", + help = "Filename to output the feature map for debugging purposes." + )] + export_feature_map: Option, } fn prepare_count_hashmap(gtf_end_sorted: &HashMap, Vec)>) -> HashMap { @@ -173,6 +218,7 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap = Vec::new(); for line in reader.lines() { counter += 1; if counter % 100000 == 0 { @@ -207,31 +253,39 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap, Vec)> = HashMap::new(); - for (chr, mut features) in map { - features.sort_by(|a, b| a.end.cmp(&b.end)); - for i in 0..features.len() { - features[i].end_sorted_index = i; + for (chr, mut end_sorted) in map { + end_sorted.sort_by(|a, b| a.end.cmp(&b.end)); + for i in 0..end_sorted.len() { + end_sorted[i].end_sorted_index = i; } - let mut start_sorted = features.clone(); + let mut start_sorted = end_sorted.clone(); start_sorted.sort_by(|a, b| a.start.cmp(&b.start)); for i in 0..start_sorted.len() { start_sorted[i].start_sorted_index = i; // also add the start index to the end_sorted features - features[start_sorted[i].end_sorted_index].start_sorted_index = i; + end_sorted[start_sorted[i].end_sorted_index].start_sorted_index = i; } - result.insert(chr, (features, start_sorted)); + result.insert(chr, (end_sorted, start_sorted)); } eprintln!("{} GFF lines processed.", counter); @@ -340,7 +394,7 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap1 { feature_name= String::default(); // construct partial reads for each cigar element with AlnMatch @@ -408,7 +464,7 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, Vec)>, reference: &String, features: &(Vec, Vec), start_pos: u32, end_pos: u32, ambiguous: &mut bool) -> String { +fn process_partial_read(features: &(Vec, Vec), start_pos: u32, end_pos: u32, ambiguous: &mut bool) -> String { let mut feature_name = String::default(); - let mut startindex = get_start_index(&features.0, start_pos, end_pos); + let startindex = get_start_index(&features.0, start_pos, end_pos); let endindex = get_end_index(&features.1, start_pos, end_pos); - if startindex >= features.0.len() { + let start_feature_end_index = features.0[startindex].end_sorted_index; + let end_feature_start_index = features.1[endindex].start_sorted_index; + + let index_range = min(startindex, start_feature_end_index)..max(endindex, end_feature_start_index); + + // get all feature in index_range from both start and end sorted vectors, if they are the same, only collect one + let mut overlapping_features: Vec = vec![]; + for i in index_range { + let feature = features.0[i].clone(); + // if feature (chrom + position +name) is already in the list, skip it + if overlapping_features.iter().any(|f| f.chr == feature.chr && f.start == feature.start && f.end == feature.end && f.name == feature.name) { + continue; + } + overlapping_features.push(feature); + let feature = features.1[i].clone(); + if overlapping_features.iter().any(|f| f.chr == feature.chr && f.start == feature.start && f.end == feature.end && f.name == feature.name) { + continue; + } + overlapping_features.push(feature); + } + + + + if start_pos == 161647060 { + eprintln!("startindex: {}, endindex: {}", min(startindex, start_feature_end_index), max(endindex, end_feature_start_index)); + } + + if min(startindex, start_feature_end_index) >= features.0.len() { // No feature found for this read feature_name = String::default(); *ambiguous = false; return feature_name; } - let mut current_feature = >f_end_sorted[reference].0[startindex]; - while startindex < features.0.len() && endindex > current_feature.end_sorted_index { + for current_feature in overlapping_features.iter() { + if start_pos == 161647060 { + //eprintln!("index: {}, current_feature: {:?}", index, current_feature); + } + if feature_name == String::default() { if current_feature.start <= start_pos && current_feature.end >= end_pos { feature_name = current_feature.name.clone(); } else { - startindex += 1; - if startindex < features.0.len() { - current_feature = >f_end_sorted[reference].0[startindex]; - } + //if index < features.0.len() { + // current_feature = >f_sorted[reference].1[index]; + //} continue; } } @@ -509,10 +594,6 @@ fn process_partial_read(gtf_end_sorted: &HashMap, Vec usize{ }) { Ok(index) | Err(index) => { //eprintln!("f.start>end_pos: {}, f.start: {}, end_pos: {}, index: {}, {}, feature:{:?}", features.len(), features[index].start, end_pos, index, features[index].start > end_pos, features[index]); - // TODO: fix this, it is not correct, it most likely doesn't hurt the results, but it hurts speed - if index+50 end_pos { - index+50 - } else { - features.len()-1 - } + index + 1 } }; endindex @@ -550,13 +626,12 @@ fn get_start_index(features: &Vec, start_pos: u32, _end_pos: u32) -> us }) { Ok(index) | Err(index) => { //eprintln!("f.end 0 && features[startindex-1].end > start_pos { - startindex -= 1; + if index > 0 { + index - 1 + } else { + index } - startindex } }; - startindex + features[startindex].end_sorted_index } From f870d811bdd23ca43e3d473210072f2c06320571 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 31 Jan 2024 18:07:00 +0100 Subject: [PATCH 02/52] dependencies for intervaltree --- src/feature.rs | 12 ++ src/interval.rs | 143 ++++++++++++++++++++ src/intervaltree.rs | 18 +++ src/node.rs | 318 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 491 insertions(+) create mode 100644 src/feature.rs create mode 100644 src/interval.rs create mode 100644 src/intervaltree.rs create mode 100644 src/node.rs diff --git a/src/feature.rs b/src/feature.rs new file mode 100644 index 0000000..067523f --- /dev/null +++ b/src/feature.rs @@ -0,0 +1,12 @@ +// Struct to store the features +#[derive(Debug, Eq, PartialEq, Hash, Clone)] +pub struct Feature { + //type_: String, + pub name: String, + pub chr: String, + pub start: u32, + pub end: u32, + pub start_sorted_index: usize, + pub end_sorted_index: usize, + +} \ No newline at end of file diff --git a/src/interval.rs b/src/interval.rs new file mode 100644 index 0000000..666b6d2 --- /dev/null +++ b/src/interval.rs @@ -0,0 +1,143 @@ +use crate::Feature; + +#[derive(Debug, Eq, PartialEq, Hash, Clone)] +pub struct Interval { + pub start: i32, + pub end: i32, + //optional data + pub data: Option, +} + +impl Interval { + pub fn new(start: i32, end: i32, data: Option) -> Self { + Interval { start, end, data } + } + + pub fn overlaps(&self, other: &Interval) -> bool { + other.start < self.end && other.end > self.start + } + + pub fn overlap_size(&self, other: &Interval) -> i32 { + if self.overlaps(other) { + let start = std::cmp::max(self.start, other.start); + let end = std::cmp::min(self.end, other.end); + end - start + } else { + 0 + } + } + + pub fn contains_point(&self, point: i32) -> bool { + self.start <= point && point < self.end + } + + pub fn range_matches(&self, other: &Interval) -> bool { + self.start == other.start && self.end == other.end + } + + pub fn contains_interval(&self, other: &Interval) -> bool { + self.start <= other.start && self.end >= other.end + } + + pub fn distance_to(&self, other: &Interval) -> i32 { + if self.overlaps(other) { + 0 + } else { + if self.start > other.end { + self.start - other.end + } else { + other.start - self.end + } + } + } + + pub fn distance_to_point(&self, point: i32) -> i32 { + if self.contains_point(point) { + 0 + } else { + if self.start > point { + self.start - point + } else { + point - self.end + } + } + } + + pub fn is_null(&self) -> bool { + self.start>=self.end + } + + pub fn length(&self) -> i32 { + if self.is_null() { + 0 + } else { + self.end - self.start + } + } + + fn raise_if_null(&self, other: &Interval) { + if self.is_null() || other.is_null(){ + panic!("Cannot perform operation on null interval"); + } + } + pub fn lt(&self, other: &Interval) -> bool { + // Strictly less than + self.raise_if_null(other); + self.end <= other.start + } + + pub fn le(&self, other: &Interval) -> bool { + // Less than or overlaps + self.raise_if_null(other); + self.end < other.end + } + + pub fn gt(&self, other: &Interval) -> bool { + // Strictly greater than + self.raise_if_null(other); + self.start > other.end + } + + pub fn ge(&self, other: &Interval) -> bool { + // Greater than or overlaps + self.raise_if_null(other); + self.start >= other.start + } + +} + +impl PartialOrd for Interval { + fn partial_cmp(&self, other: &Self) -> Option { + // first by start, then by end, then by data.name (alphabetically) + Some(self.start.cmp(&other.start) + .then(self.end.cmp(&other.end)) + .then(self.data.as_ref().unwrap().name.cmp(&other.data.as_ref().unwrap().name))) + } +} + +impl Ord for Interval { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + // check if both intervals are not null + if self.is_null() || other.is_null() { + // throw error + panic!("Cannot compare null intervals"); + } + + // first by start, then by end, then by data.name (alphabetically) + self.start.cmp(&other.start) + .then(self.end.cmp(&other.end)) + .then(self.data.as_ref().unwrap().name.cmp(&other.data.as_ref().unwrap().name)) + + } +} + +impl std::fmt::Display for Interval { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match &self.data { + Some(feature) => write!(f, "Interval({}, {}, {})", self.start, self.end, feature.name), + None => write!(f, "Interval({}, {})", self.start, self.end), + } + } +} + + diff --git a/src/intervaltree.rs b/src/intervaltree.rs new file mode 100644 index 0000000..f3dc302 --- /dev/null +++ b/src/intervaltree.rs @@ -0,0 +1,18 @@ +use crate::Feature; +use crate::Interval; + +pub struct IntervalTree { + intervals: Vec, +} + +impl IntervalTree { + pub fn new() -> Self { + IntervalTree { + intervals: Vec::new(), + } + } + + pub fn insert(&mut self, start: i32, end: i32, data: Option) { + self.intervals.push(Interval::new(start, end, data)); + } +} \ No newline at end of file diff --git a/src/node.rs b/src/node.rs new file mode 100644 index 0000000..4968760 --- /dev/null +++ b/src/node.rs @@ -0,0 +1,318 @@ +#![allow(dead_code)] + +use crate::interval::{self, Interval}; +use std::collections::HashSet; + +#[derive(Debug, Eq, PartialEq, Clone)] +pub struct Node { + pub x_center: i32, + pub s_center: HashSet, + left_node: Option>, + right_node: Option>, + pub depth: i32, + pub balance: i32, +} + +impl Node { + pub fn new(x_center: i32, s_center: HashSet) -> Self { + Node { + x_center, + s_center, + left_node: None, + right_node: None, + depth: 0, + balance: 0, + } + } + + pub fn new_empty() -> Self { + Node { + x_center: 0, + s_center: HashSet::new(), + left_node: None, + right_node: None, + depth: 0, + balance: 0, + } + } + + pub fn from_interval(interval: Interval) -> Self { + let mut s_center = HashSet::new(); + s_center.insert(interval.clone()); + Node::new(interval.start, s_center) + } + + pub fn from_intervals(intervals: Vec) -> Option> { + if intervals.is_empty() { + None + } else { + let mut sorted_intervals = intervals; + sorted_intervals.sort(); + Node::from_sorted_intervals(sorted_intervals) + } + } + + pub fn from_sorted_intervals(intervals: Vec) -> Option> { + if intervals.is_empty() { + None + } else { + let mid = intervals.len() / 2; + let mut s_center = HashSet::new(); + s_center.insert(intervals[mid].clone()); + + let mut node = Node::new(intervals[mid].start, s_center); + + let left_intervals = intervals[0..mid].to_vec(); + let right_intervals = intervals[mid+1..].to_vec(); + + node.left_node = Node::from_sorted_intervals(left_intervals); + node.right_node = Node::from_sorted_intervals(right_intervals); + + let mut node = Some(Box::new(node)); + // rotate the tree to balance it + node = node?.rotate(); + node + + } + + } + + pub fn center_hit(&self, interval: &Interval) -> bool { + interval.contains_point(self.x_center) + } + + pub fn hit_branch(&self, interval: &Interval) -> bool { + interval.start > self.x_center + } + + pub fn refresh_balance(&mut self) { + let left_depth = self.left_node.as_ref().map_or(0, |n| n.depth); + let right_depth = self.right_node.as_ref().map_or(0, |n| n.depth); + self.depth = 1 + std::cmp::max(left_depth, right_depth); + self.balance = right_depth - left_depth; + } + + pub fn compute_depth(&mut self) -> i32 { + let left_depth = self.left_node.as_mut().map_or(0, |n| n.compute_depth()); + let right_depth = self.right_node.as_mut().map_or(0, |n| n.compute_depth()); + self.depth = 1 + std::cmp::max(left_depth, right_depth); + self.depth + } + + pub fn rotate(&mut self) -> Option> { + self.refresh_balance(); + if self.balance.abs() < 2 { + return Some(Box::new(self.clone())); + } + let my_heavy = self.balance > 0; + let child_heavy = match my_heavy { + true => self.right_node.as_ref()?.balance > 0, + false => self.left_node.as_ref()?.balance > 0, + }; + if my_heavy == child_heavy || self.right_node.as_ref()?.balance == 0 { + self.srotate() + } else { + self.drotate() + } + } + + pub fn srotate(&mut self) -> Option> { + let heavy = self.balance > 0; + let mut save = match heavy { + true => self.right_node.take(), + false => self.left_node.take(), + }?; + match heavy { + true => self.right_node = save.left_node.take(), + false => self.left_node = save.right_node.take(), + }; + save.rotate(); // Needed to ensure the 2 and 3 are balanced under new subnode + Some(save) + } + + pub fn drotate(&mut self) -> Option> { + let my_heavy = self.balance > 0; + match my_heavy { + true => self.right_node.as_mut()?.srotate(), + false => self.left_node.as_mut()?.srotate(), + }; + self.refresh_balance(); + self.srotate() + } + + + pub fn add(&mut self, interval: Interval) -> &mut Self { + if self.center_hit(&interval) { + self.s_center.insert(interval); + } else { + let direction = self.hit_branch(&interval); + match direction { + true => { + if let Some(right_node) = &mut self.right_node { + right_node.add(interval); + } else { + self.right_node = Some(Box::new(Node::from_interval(interval))); + } + }, + false => { + if let Some(left_node) = &mut self.left_node { + left_node.add(interval); + } else { + self.left_node = Some(Box::new(Node::from_interval(interval))); + } + }, + } + self.refresh_balance(); + } + self + } + + pub fn remove(&mut self, interval: Interval) -> Result<&mut Self, &'static str> { + self.remove_interval_helper(interval, true) + } + + pub fn discard(&mut self, interval: Interval) -> Result<&mut Self, &'static str> { + self.remove_interval_helper(interval, false) + } + + pub fn remove_interval_helper(&mut self, interval: Interval, should_raise_error: bool) -> Result<&mut Self, &'static str> { + if self.center_hit(&interval) { + if !self.s_center.remove(&interval) && should_raise_error { + return Err("Interval not found"); + } + if self.s_center.is_empty() { + // implement prune method here + } + } else { + let direction = self.hit_branch(&interval); + match direction { + true => { + if let Some(right_node) = &mut self.right_node { + right_node.remove_interval_helper(interval, should_raise_error)?; + } else if should_raise_error { + return Err("Interval not found"); + } + }, + false => { + if let Some(left_node) = &mut self.left_node { + left_node.remove_interval_helper(interval, should_raise_error)?; + } else if should_raise_error { + return Err("Interval not found"); + } + }, + } + self.refresh_balance(); + } + Ok(self) + } + + pub fn search_overlap(&self, point_list: Vec) -> Vec { + let mut result = Vec::new(); + for point in point_list { + result.extend(self.search_point(point)); + } + result + } + + pub fn search_point(&self, point: i32) -> Vec { + let mut result = Vec::new(); + for interval in &self.s_center { + if interval.contains_point(point) { + result.push(interval.clone()); + } + } + if point < self.x_center { + if let Some(left_node) = &self.left_node { + result.extend(left_node.search_point(point)); + } + } else if point > self.x_center { + if let Some(right_node) = &self.right_node { + result.extend(right_node.search_point(point)); + } + } + result + } + + pub fn contains_point(&self, point: i32) -> bool { + for interval in &self.s_center { + if interval.contains_point(point) { + return true; + } + } + if point < self.x_center { + if let Some(left_node) = &self.left_node { + return left_node.contains_point(point); + } + } else if point > self.x_center { + if let Some(right_node) = &self.right_node { + return right_node.contains_point(point); + } + } + false + } + + pub fn all_children(&self) -> Vec { + let mut result = Vec::new(); + for interval in &self.s_center { + result.push(interval.clone()); + } + if let Some(left_node) = &self.left_node { + result.extend(left_node.all_children()); + } + if let Some(right_node) = &self.right_node { + result.extend(right_node.all_children()); + } + result + } + + pub fn count_nodes(&self) -> usize { + let mut result = 1; + if let Some(left_node) = &self.left_node { + result += left_node.count_nodes(); + } + if let Some(right_node) = &self.right_node { + result += right_node.count_nodes(); + } + result + } + // indent by default is 0 + pub fn print_structure(&self, indent: usize, to_string:bool) -> Vec { + let newline = "\n"; + let spaces = " ".repeat(indent); + + let mut result = vec![format!("{}{}", self, newline)]; + if self.s_center.len() > 0 { + for interval in &self.s_center { + result.push(format!("{} {}{}", spaces, interval, newline)); + } + } + if let Some(left_node) = &self.left_node { + result.push(format!("{}{}{}", spaces, "Left:", newline)); + result.extend(left_node.print_structure(indent+1,true)); + } + if let Some(right_node) = &self.right_node { + result.push(format!("{}{}{}", spaces, "Right:", newline)); + result.extend(right_node.print_structure(indent+1,true)); + } + + // join the vector into a string + let result = result.join(""); + + if to_string { + return vec![result] + } else { + println!("{}", result); + return vec![] + } + + } +} + +// display format + +impl std::fmt::Display for Node { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + //"Node<{0}, depth={1}, balance={2}>" + write!(f, "Node<{}, depth={}, balance={}>", self.x_center, self.depth, self.balance) + } +} \ No newline at end of file From 8381680b6f9d48148f6788b895e62422e2ae63fd Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 31 Jan 2024 18:12:30 +0100 Subject: [PATCH 03/52] allow dead code in subfiles and remove unused imports --- src/interval.rs | 2 ++ src/node.rs | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/interval.rs b/src/interval.rs index 666b6d2..1bbcbfa 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -1,3 +1,5 @@ +#![allow(dead_code)] + use crate::Feature; #[derive(Debug, Eq, PartialEq, Hash, Clone)] diff --git a/src/node.rs b/src/node.rs index 4968760..de81058 100644 --- a/src/node.rs +++ b/src/node.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use crate::interval::{self, Interval}; +use crate::interval::Interval; use std::collections::HashSet; #[derive(Debug, Eq, PartialEq, Clone)] From cfc4b93342f84bcc2538f66f81237b7dd00ad5d6 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 31 Jan 2024 20:45:18 +0100 Subject: [PATCH 04/52] Refactor interval tree initialization in main.rs --- src/main.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main.rs b/src/main.rs index b4850fc..7079727 100755 --- a/src/main.rs +++ b/src/main.rs @@ -19,15 +19,14 @@ use node::Node; fn main() { // test intervaltree - let mut tree = IntervalTree::new(); - tree.insert(0, 10, Some(Feature { + let mut tree = IntervalTree::from_tuples(vec!((0, 10, Some(Feature { name: "test".to_string(), chr: "chr1".to_string(), start: 0, end: 10, start_sorted_index: 0, end_sorted_index: 0 - })); + })))); let interval = Interval::new(0, 10, Some(Feature { name: "test".to_string(), From 155f73f7caada049cd651f551856ebaa1225e7ee Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 31 Jan 2024 20:46:18 +0100 Subject: [PATCH 05/52] Start implementing the actual IntervalTree structure and functions. --- src/intervaltree.rs | 271 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 265 insertions(+), 6 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index f3dc302..47d795d 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -1,18 +1,277 @@ +use std::collections::HashMap; + use crate::Feature; use crate::Interval; +use crate::Node; pub struct IntervalTree { - intervals: Vec, + all_intervals: Vec, + top_node: Option>, + boundary_table: HashMap } impl IntervalTree { - pub fn new() -> Self { - IntervalTree { - intervals: Vec::new(), + pub fn new(intervals: Option>) -> Self { + if let Some(intervals) = intervals { + + // get unique intervals + let mut unique_intervals: Vec = Vec::new(); + for interval in intervals { + if !unique_intervals.contains(&interval) { + unique_intervals.push(interval); + } + } + // check if intervals are not null + for interval in &unique_intervals { + if interval.is_null() { + panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree"); + } + } + let mut it = IntervalTree { + all_intervals: unique_intervals.clone(), + top_node: Node::from_intervals(unique_intervals.clone()), + boundary_table: HashMap::new(), + }; + + for interval in &unique_intervals { + it.add_boundaries(interval); + } + return it; + } + else { + IntervalTree { + all_intervals: Vec::new(), + top_node: None, + boundary_table: HashMap::new(), + } + } + } + + pub fn from_tuples(tuples: Vec<(i32,i32, Option)>) -> Self { + let mut intervals: Vec = Vec::new(); + for tuple in tuples { + let interval = Interval::new(tuple.0, tuple.1, tuple.2); + intervals.push(interval); } + IntervalTree::new(Some(intervals)) + } + + fn add_boundaries(&mut self, interval: &Interval) { + let start = interval.start; + let end = interval.end; + *self.boundary_table.entry(start).or_insert(0) += 1; + *self.boundary_table.entry(end).or_insert(0) += 1; } - pub fn insert(&mut self, start: i32, end: i32, data: Option) { - self.intervals.push(Interval::new(start, end, data)); + fn remove_boundaries(&mut self, interval: &Interval) { + let start = interval.start; + let end = interval.end; + if let Some(count) = self.boundary_table.get_mut(&start) { + *count -= 1; + if *count == 0 { + self.boundary_table.remove(&start); + } + } + if let Some(count) = self.boundary_table.get_mut(&end) { + *count -= 1; + if *count == 0 { + self.boundary_table.remove(&end); + } + } } + + pub fn add(&mut self, interval: Interval) { + if interval.is_null() { + panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree"); + } + // check if interval is unique + if self.all_intervals.contains(&interval) { + return; + } + + self.all_intervals.push(interval.clone()); + self.add_boundaries(&interval); + if let Some(top_node) = &mut self.top_node { + top_node.add(interval); + } else { + self.top_node = Node::from_intervals(vec![interval]); + } + } + + pub fn addi(&mut self, start: i32, end: i32, data: Option) { + let interval = Interval::new(start, end, data); + self.add(interval); + } + + pub fn update(&mut self, intervals: Vec) { + for interval in intervals { + self.add(interval); + } + } + + pub fn remove(&mut self, interval: &Interval) { + if !self.all_intervals.contains(interval) { + return; + } + self.all_intervals.retain(|x| !x.range_matches(interval)); + self.remove_boundaries(interval); + if let Some(top_node) = &mut self.top_node { + let _ = top_node.remove(interval.clone()); + } + } + + pub fn removei(&mut self, start: i32, end: i32, data: Option) { + let interval = Interval::new(start, end, data); + self.remove(&interval); + } + + pub fn discard(&mut self, interval: &Interval) { + if !self.all_intervals.contains(interval) { + return; + } + self.all_intervals.retain(|x| !x.range_matches(interval)); + self.remove_boundaries(interval); + if let Some(top_node) = &mut self.top_node { + let _ = top_node.discard(interval.clone()); + } + } + + pub fn discardi(&mut self, start: i32, end: i32, data: Option) { + let interval = Interval::new(start, end, data); + self.discard(&interval); + } + + pub fn difference(&self, other: &IntervalTree) -> IntervalTree { + let mut result: Vec = Vec::new(); + for interval in &self.all_intervals { + if !other.all_intervals.contains(interval) { + result.push(interval.clone()); + } + } + IntervalTree::new(Some(result)) + } + + pub fn difference_update(&mut self, other: &IntervalTree) { + // discard intervals in self that are also in other + for interval in &other.all_intervals { + if self.all_intervals.contains(interval) { + self.discard(interval); + } + } + } + + pub fn union(&self, other: &IntervalTree) -> IntervalTree { + // return a new IntervalTree with all intervals from self and other + let mut result: Vec = Vec::new(); + for interval in &self.all_intervals { + result.push(interval.clone()); + } + for interval in &other.all_intervals { + if !result.contains(interval) { + result.push(interval.clone()); + } + } + IntervalTree::new(Some(result)) + } + + pub fn intersection(&self, other: &IntervalTree) -> IntervalTree { + // return a new IntervalTree with all intervals that are in both self and other + let mut result: Vec = Vec::new(); + let (shorter, longer) = if self.len() < other.len() { + (&self.all_intervals, &other.all_intervals) + } else { + (&other.all_intervals, &self.all_intervals) + }; + for interval in shorter { + if longer.contains(interval) { + result.push(interval.clone()); + } + } + IntervalTree::new(Some(result)) + } + + pub fn intersection_update(&mut self, other: &IntervalTree) { + // remove intervals from self unless they are also in other + let intervals = self.all_intervals.clone(); + for interval in intervals { + if !other.all_intervals.contains(&interval) { + self.remove(&interval); + } + } + } + + pub fn symmetric_difference(&self, other: &IntervalTree) -> IntervalTree { + // return a new IntervalTree with all intervals that are in either self or other but not both + let mut result: Vec = Vec::new(); + for interval in &self.all_intervals { + if !other.all_intervals.contains(interval) { + result.push(interval.clone()); + } + } + for interval in &other.all_intervals { + if !self.all_intervals.contains(interval) { + result.push(interval.clone()); + } + } + IntervalTree::new(Some(result)) + } + + pub fn symmetric_difference_update(&mut self, other: &mut IntervalTree) { + // remove intervals from self unless they are also in other + let intervals = self.all_intervals.clone(); + let other_intervals = other.all_intervals.clone(); + for interval in intervals { + if other_intervals.contains(&interval) { + self.remove(&interval); + other.remove(&interval); + } + } + self.update(other.all_intervals.clone()); + } + + pub fn clear(&mut self) { + self.all_intervals.clear(); + self.top_node = None; + self.boundary_table.clear(); + } + + pub fn is_empty(&self) -> bool { + self.all_intervals.is_empty() + } + + pub fn len(&self) -> usize { + self.all_intervals.len() + } + + pub fn overlaps_point(&self, point: i32) -> bool { + if self.is_empty() { + return false; + } + // use top_node to find overlapping intervals + if let Some(top_node) = &self.top_node { + return top_node.as_ref().contains_point(point) + } + false + } + + pub fn overlaps_range(&self, start: i32, end: i32) -> bool { + if self.is_empty() { + return false; + } + if start >= end { + return false; + } + if self.overlaps_point(start) { + return true; + } + // begin < boundary < end + for boundary in self.boundary_table.keys() { + if start < *boundary && *boundary < end { + return true; + } + } + false + } + + } \ No newline at end of file From 0f1633c46f5110a9f9c9e9cb93c9cde21ee64e18 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Thu, 1 Feb 2024 12:25:20 +0100 Subject: [PATCH 06/52] Refactor IntervalTree implementation --- src/intervaltree.rs | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 47d795d..2056db0 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -1,26 +1,30 @@ +#![allow(dead_code)] + use std::collections::HashMap; +use std::collections::HashSet; use crate::Feature; use crate::Interval; use crate::Node; pub struct IntervalTree { - all_intervals: Vec, - top_node: Option>, - boundary_table: HashMap + pub all_intervals: HashSet, + pub top_node: Option>, + pub boundary_table: HashMap } impl IntervalTree { pub fn new(intervals: Option>) -> Self { if let Some(intervals) = intervals { - + eprintln!("creating IntervalTree"); // get unique intervals - let mut unique_intervals: Vec = Vec::new(); + let mut unique_intervals: HashSet = HashSet::new(); for interval in intervals { - if !unique_intervals.contains(&interval) { - unique_intervals.push(interval); - } + unique_intervals.insert(interval); } + // convert to vector + //let unique_intervals: Vec = unique_intervals.into_iter().collect(); + eprintln!("filtered intervals"); // check if intervals are not null for interval in &unique_intervals { if interval.is_null() { @@ -32,27 +36,31 @@ impl IntervalTree { top_node: Node::from_intervals(unique_intervals.clone()), boundary_table: HashMap::new(), }; + eprintln!("created top node"); for interval in &unique_intervals { it.add_boundaries(interval); } + eprintln!("added boundaries"); return it; } else { IntervalTree { - all_intervals: Vec::new(), + all_intervals: HashSet::new(), top_node: None, boundary_table: HashMap::new(), } } } - pub fn from_tuples(tuples: Vec<(i32,i32, Option)>) -> Self { + pub fn from_tuples(tuples: Vec<(i32,i32, Option)>) -> IntervalTree { let mut intervals: Vec = Vec::new(); + eprintln!("creating intervals"); for tuple in tuples { let interval = Interval::new(tuple.0, tuple.1, tuple.2); intervals.push(interval); } + eprintln!("created intervals"); IntervalTree::new(Some(intervals)) } @@ -89,12 +97,14 @@ impl IntervalTree { return; } - self.all_intervals.push(interval.clone()); + self.all_intervals.insert(interval.clone()); self.add_boundaries(&interval); if let Some(top_node) = &mut self.top_node { top_node.add(interval); } else { - self.top_node = Node::from_intervals(vec![interval]); + let mut intervals: HashSet = HashSet::new(); + intervals.insert(interval.clone()); + self.top_node = Node::from_intervals(intervals); } } @@ -103,7 +113,7 @@ impl IntervalTree { self.add(interval); } - pub fn update(&mut self, intervals: Vec) { + pub fn update(&mut self, intervals: HashSet) { for interval in intervals { self.add(interval); } From 172f4c17315dce5902d7f9e30e1c2ed656849d16 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Thu, 1 Feb 2024 12:25:29 +0100 Subject: [PATCH 07/52] Add file writing functionality to Node struct --- src/node.rs | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/src/node.rs b/src/node.rs index de81058..26810e7 100644 --- a/src/node.rs +++ b/src/node.rs @@ -1,7 +1,8 @@ #![allow(dead_code)] use crate::interval::Interval; -use std::collections::HashSet; +use std::{collections::HashSet, fs::File}; +use std::io::Write; #[derive(Debug, Eq, PartialEq, Clone)] pub struct Node { @@ -42,11 +43,11 @@ impl Node { Node::new(interval.start, s_center) } - pub fn from_intervals(intervals: Vec) -> Option> { + pub fn from_intervals(intervals: HashSet) -> Option> { if intervals.is_empty() { None } else { - let mut sorted_intervals = intervals; + let mut sorted_intervals = intervals.into_iter().collect::>(); sorted_intervals.sort(); Node::from_sorted_intervals(sorted_intervals) } @@ -306,6 +307,27 @@ impl Node { } } + + pub fn write_structure(&self, f: &mut File, indent: usize) -> std::fmt::Result { + let newline = "\n"; + let spaces = " ".repeat(indent); + + let _ = write!(f, "{}{}", self, newline); + if self.s_center.len() > 0 { + for interval in &self.s_center { + let _ = write!(f, "{} {}{}", spaces, interval, newline); + } + } + if let Some(left_node) = &self.left_node { + let _ = write!(f, "{}{}{}", spaces, "Left:", newline); + left_node.write_structure(f, indent+1)?; + } + if let Some(right_node) = &self.right_node { + let _ = write!(f, "{}{}{}", spaces, "Right:", newline); + right_node.write_structure(f, indent+1)?; + } + Ok(()) + } } // display format From 2fd3b4299253c733cc0227c64bd72886d8f78561 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Thu, 1 Feb 2024 12:26:01 +0100 Subject: [PATCH 08/52] Prepare the main functionality to deal with new intervaltree implementation. Non functional! --- src/main.rs | 165 +++++++++++----------------------------------------- 1 file changed, 33 insertions(+), 132 deletions(-) diff --git a/src/main.rs b/src/main.rs index 7079727..53f6828 100755 --- a/src/main.rs +++ b/src/main.rs @@ -4,7 +4,6 @@ use bam::BamReader; use feature::Feature; use intervaltree::IntervalTree; use interval::Interval; -use std::cmp::{max, min}; use std::collections::HashMap; use std::fs::File; use std::io::{BufRead, BufReader, Write}; @@ -18,36 +17,6 @@ mod node; use node::Node; fn main() { - // test intervaltree - let mut tree = IntervalTree::from_tuples(vec!((0, 10, Some(Feature { - name: "test".to_string(), - chr: "chr1".to_string(), - start: 0, - end: 10, - start_sorted_index: 0, - end_sorted_index: 0 - })))); - - let interval = Interval::new(0, 10, Some(Feature { - name: "test".to_string(), - chr: "chr1".to_string(), - start: 0, - end: 10, - start_sorted_index: 0, - end_sorted_index: 0 - })); - - println!("{:?}",interval); - let args = Args::from_args(); - - // test node - read_gtf(&args.gtf, args.t.as_str()); - - // exit(1) to prevent the rest of the program from running - std::process::exit(1); - - - // Command line arguments let args = Args::from_args(); @@ -66,23 +35,24 @@ fn main() { // bam fields: https://docs.rs/bam/0.3.0/bam/record/struct.Record.html // Read the gtf file - let gtf_end_sorted = read_gtf(&args.gtf, args.t.as_str()); + let gtf = read_gtf(&args.gtf, args.t.as_str()); - if args.export_feature_map.is_some() { + if args.export_feature_map.is_some() { let mut file = File::create(args.export_feature_map.clone().unwrap()).expect("Unable to create file"); - for (chr, features) in gtf_end_sorted.iter() { - for feature in features.0.iter() { - file.write_all(format!("{}\t{}\t{}\t{}\t{}\t{}\n", chr, feature.start, feature.end, feature.name, feature.start_sorted_index, feature.end_sorted_index).as_bytes()).expect("Unable to write data"); - } + for (chr, tree) in gtf.iter() { + file.write_all(format!("{}:\n", chr).as_bytes()).expect("Unable to write data"); + let _ = tree.top_node.clone().unwrap().write_structure(&mut file, 0); } } + // exit(1) to prevent the rest of the program from running + std::process::exit(1); - let mut counts = prepare_count_hashmap(>f_end_sorted); + let mut counts = prepare_count_hashmap(>f); let mut counter = 0; - count_reads(bam, &mut counter, &mut counts, &args, reference_names, gtf_end_sorted); + count_reads(bam, &mut counter, &mut counts, &args, reference_names, gtf); if args.counts_output.is_some() { write_counts(counts, args, counter); @@ -194,12 +164,12 @@ struct Args { export_feature_map: Option, } -fn prepare_count_hashmap(gtf_end_sorted: &HashMap, Vec)>) -> HashMap { - let mut counts = HashMap::with_capacity(gtf_end_sorted.len()); +fn prepare_count_hashmap(gtf: &HashMap) -> HashMap { + let mut counts = HashMap::with_capacity(gtf.len()); // add all features to the map - for features in gtf_end_sorted.values() { - for feature in features.0.iter() { - counts.entry(feature.name.clone()).or_default(); + for features in gtf.values() { + for feature in features.all_intervals.iter() { + counts.entry(feature.data.as_ref().unwrap().name.clone()).or_insert(0); } } @@ -212,12 +182,11 @@ fn prepare_count_hashmap(gtf_end_sorted: &HashMap, Vec HashMap, Vec)> { - let mut map: HashMap> = HashMap::new(); +fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap { + let mut map: HashMap> = HashMap::new(); let file = File::open(file_path).expect("Kan het bestand niet openen"); let reader = BufReader::new(file); let mut counter = 0; - let mut intervals: Vec = Vec::new(); for line in reader.lines() { counter += 1; if counter % 100000 == 0 { @@ -258,33 +227,23 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap, Vec)> = HashMap::new(); + let mut result: HashMap = HashMap::new(); - for (chr, mut end_sorted) in map { - end_sorted.sort_by(|a, b| a.end.cmp(&b.end)); - for i in 0..end_sorted.len() { - end_sorted[i].end_sorted_index = i; - } - let mut start_sorted = end_sorted.clone(); - start_sorted.sort_by(|a, b| a.start.cmp(&b.start)); - for i in 0..start_sorted.len() { - start_sorted[i].start_sorted_index = i; - // also add the start index to the end_sorted features - end_sorted[start_sorted[i].end_sorted_index].start_sorted_index = i; - } - result.insert(chr, (end_sorted, start_sorted)); + for (chr, intervals) in map { + let tree = IntervalTree::new(Some(intervals)); + result.insert(chr, tree); + } eprintln!("{} GFF lines processed.", counter); @@ -385,7 +344,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf_end_sorted: HashMap, Vec)>) { +fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf_end_sorted: HashMap) { for record in bam { *counter += 1; if *counter % 100000 == 0 { @@ -400,6 +359,8 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, Vec), start_pos: u32, end_pos: u32, ambiguous: &mut bool) -> String { +fn process_partial_read(features: &IntervalTree, start_pos: u32, end_pos: u32, ambiguous: &mut bool) -> String { let mut feature_name = String::default(); - let startindex = get_start_index(&features.0, start_pos, end_pos); - let endindex = get_end_index(&features.1, start_pos, end_pos); - - let start_feature_end_index = features.0[startindex].end_sorted_index; - let end_feature_start_index = features.1[endindex].start_sorted_index; - - let index_range = min(startindex, start_feature_end_index)..max(endindex, end_feature_start_index); - - // get all feature in index_range from both start and end sorted vectors, if they are the same, only collect one - let mut overlapping_features: Vec = vec![]; - for i in index_range { - let feature = features.0[i].clone(); - // if feature (chrom + position +name) is already in the list, skip it - if overlapping_features.iter().any(|f| f.chr == feature.chr && f.start == feature.start && f.end == feature.end && f.name == feature.name) { - continue; - } - overlapping_features.push(feature); - let feature = features.1[i].clone(); - if overlapping_features.iter().any(|f| f.chr == feature.chr && f.start == feature.start && f.end == feature.end && f.name == feature.name) { - continue; - } - overlapping_features.push(feature); - } - - - - if start_pos == 161647060 { - eprintln!("startindex: {}, endindex: {}", min(startindex, start_feature_end_index), max(endindex, end_feature_start_index)); - } - - if min(startindex, start_feature_end_index) >= features.0.len() { - // No feature found for this read - feature_name = String::default(); - *ambiguous = false; - return feature_name; - } - for current_feature in overlapping_features.iter() { - if start_pos == 161647060 { - //eprintln!("index: {}, current_feature: {:?}", index, current_feature); - } - - if feature_name == String::default() { - if current_feature.start <= start_pos && current_feature.end >= end_pos { - feature_name = current_feature.name.clone(); - } - else { - //if index < features.0.len() { - // current_feature = >f_sorted[reference].1[index]; - //} - continue; - } - } - // check if same feature name, otherwise ambiguous - if feature_name != current_feature.name && current_feature.start <= start_pos && current_feature.end >= end_pos { - // record.name() is &[u8] - //eprintln!("Ambiguous: {}:{}-{} (position: {}); (current: {}, alternate: {}) (index: {}) (Read id: {})", reference, start_pos, end_pos, start_pos, current_feature.name, feature_name, startindex, String::from_utf8_lossy(record.name())); - *ambiguous = true; - break; - } - //println!("Feature found! {}: {}:{}-{} (position: {})", map[&reference][index].name,reference, map[&reference][index].start, map[&reference][index].end, start_pos); - } + todo!("process_partial_read"); feature_name } From 24f84c99119d2c010b78df9728279f5564efe557 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Thu, 1 Feb 2024 15:05:26 +0100 Subject: [PATCH 09/52] further updates --- src/intervaltree.rs | 31 ++++++++++++++++++++++++++++--- src/node.rs | 10 +++++----- 2 files changed, 33 insertions(+), 8 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 2056db0..61d4260 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -1,5 +1,6 @@ #![allow(dead_code)] +use std::collections::BTreeMap; use std::collections::HashMap; use std::collections::HashSet; @@ -10,7 +11,7 @@ use crate::Node; pub struct IntervalTree { pub all_intervals: HashSet, pub top_node: Option>, - pub boundary_table: HashMap + pub boundary_table: BTreeMap } impl IntervalTree { @@ -34,7 +35,7 @@ impl IntervalTree { let mut it = IntervalTree { all_intervals: unique_intervals.clone(), top_node: Node::from_intervals(unique_intervals.clone()), - boundary_table: HashMap::new(), + boundary_table: BTreeMap::new(), }; eprintln!("created top node"); @@ -48,7 +49,7 @@ impl IntervalTree { IntervalTree { all_intervals: HashSet::new(), top_node: None, - boundary_table: HashMap::new(), + boundary_table: BTreeMap::new(), } } } @@ -283,5 +284,29 @@ impl IntervalTree { false } + pub fn overlap(&self, start: i32, end: i32) -> HashSet { + // return a vector of all intervals that overlap with the given range + if self.is_empty() || start >= end { + return HashSet::new(); + } + let root = self.top_node.clone().unwrap(); + let mut result = root.search_point(start); + let boundary_table = &self.boundary_table; + let bound_begin = bisect_left(&boundary_table.keys().cloned().collect::>(), start); + let bound_end = bisect_left(&boundary_table.keys().cloned().collect::>(), end); + let overlapping_bounds = boundary_table.keys().skip(bound_begin).take(bound_end - bound_begin).collect::>(); + // make Vec<&i32> into Vec + let overlapping_bounds = overlapping_bounds.iter().map(|&x| *x).collect::>(); + result.extend(root.search_overlap(overlapping_bounds)); + result + + } + +} +fn bisect_left(arr: &[T], value: T) -> usize { + match arr.binary_search(&value) { + Ok(index) => index, + Err(index) => index, + } } \ No newline at end of file diff --git a/src/node.rs b/src/node.rs index 26810e7..7d95ca1 100644 --- a/src/node.rs +++ b/src/node.rs @@ -207,19 +207,19 @@ impl Node { Ok(self) } - pub fn search_overlap(&self, point_list: Vec) -> Vec { - let mut result = Vec::new(); + pub fn search_overlap(&self, point_list: Vec) -> HashSet { + let mut result = HashSet::new(); for point in point_list { result.extend(self.search_point(point)); } result } - pub fn search_point(&self, point: i32) -> Vec { - let mut result = Vec::new(); + pub fn search_point(&self, point: i32) -> HashSet { + let mut result = HashSet::new(); for interval in &self.s_center { if interval.contains_point(point) { - result.push(interval.clone()); + result.insert(interval.clone()); } } if point < self.x_center { From 190c5a026c1323bebdd2d4f004c562a6407f7b6e Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Fri, 2 Feb 2024 00:40:32 +0100 Subject: [PATCH 10/52] Remove unused import in intervaltree.rs --- src/intervaltree.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 61d4260..fe0321c 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -1,7 +1,6 @@ #![allow(dead_code)] use std::collections::BTreeMap; -use std::collections::HashMap; use std::collections::HashSet; use crate::Feature; From 2336956fa67b6fec08d707db2906826922337e1d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Fri, 2 Feb 2024 00:40:45 +0100 Subject: [PATCH 11/52] Add debug statement to check overlap in gtf --- src/main.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main.rs b/src/main.rs index 53f6828..f43b990 100755 --- a/src/main.rs +++ b/src/main.rs @@ -36,6 +36,8 @@ fn main() { // Read the gtf file let gtf = read_gtf(&args.gtf, args.t.as_str()); + + eprintln!("{:?}",gtf["1"].overlap(24646121, 24646123)); if args.export_feature_map.is_some() { let mut file = File::create(args.export_feature_map.clone().unwrap()).expect("Unable to create file"); From aaab8eee0161f11b052298cc24d97ff63e0bec5b Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 3 Feb 2024 11:53:22 +0100 Subject: [PATCH 12/52] Refactor IntervalTree constructor and overlap method --- src/intervaltree.rs | 30 +++++++++--------------------- 1 file changed, 9 insertions(+), 21 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index fe0321c..ee17ec5 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -16,7 +16,7 @@ pub struct IntervalTree { impl IntervalTree { pub fn new(intervals: Option>) -> Self { if let Some(intervals) = intervals { - eprintln!("creating IntervalTree"); + //eprintln!("creating IntervalTree"); // get unique intervals let mut unique_intervals: HashSet = HashSet::new(); for interval in intervals { @@ -24,7 +24,7 @@ impl IntervalTree { } // convert to vector //let unique_intervals: Vec = unique_intervals.into_iter().collect(); - eprintln!("filtered intervals"); + //eprintln!("filtered intervals"); // check if intervals are not null for interval in &unique_intervals { if interval.is_null() { @@ -36,12 +36,12 @@ impl IntervalTree { top_node: Node::from_intervals(unique_intervals.clone()), boundary_table: BTreeMap::new(), }; - eprintln!("created top node"); + //eprintln!("created top node"); for interval in &unique_intervals { it.add_boundaries(interval); } - eprintln!("added boundaries"); + //eprintln!("added boundaries"); return it; } else { @@ -283,29 +283,17 @@ impl IntervalTree { false } - pub fn overlap(&self, start: i32, end: i32) -> HashSet { + pub fn overlap(&self, start: i32, end: i32) -> HashSet<&Interval> { // return a vector of all intervals that overlap with the given range if self.is_empty() || start >= end { return HashSet::new(); } - let root = self.top_node.clone().unwrap(); + let root = self.top_node.as_ref().unwrap(); let mut result = root.search_point(start); - let boundary_table = &self.boundary_table; - let bound_begin = bisect_left(&boundary_table.keys().cloned().collect::>(), start); - let bound_end = bisect_left(&boundary_table.keys().cloned().collect::>(), end); - let overlapping_bounds = boundary_table.keys().skip(bound_begin).take(bound_end - bound_begin).collect::>(); - // make Vec<&i32> into Vec - let overlapping_bounds = overlapping_bounds.iter().map(|&x| *x).collect::>(); - result.extend(root.search_overlap(overlapping_bounds)); + for (&key, _) in self.boundary_table.range(start..end) { + result.extend(root.search_point(key)); + } result - } -} - -fn bisect_left(arr: &[T], value: T) -> usize { - match arr.binary_search(&value) { - Ok(index) => index, - Err(index) => index, - } } \ No newline at end of file From 1e729e966acc767c8508016ec953ee68c041aa15 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 3 Feb 2024 11:53:30 +0100 Subject: [PATCH 13/52] Update search_overlap and search_point to use references to Interval --- src/node.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/node.rs b/src/node.rs index 7d95ca1..a94a6d6 100644 --- a/src/node.rs +++ b/src/node.rs @@ -207,7 +207,7 @@ impl Node { Ok(self) } - pub fn search_overlap(&self, point_list: Vec) -> HashSet { + pub fn search_overlap(&self, point_list: Vec) -> HashSet<&Interval> { let mut result = HashSet::new(); for point in point_list { result.extend(self.search_point(point)); @@ -215,11 +215,11 @@ impl Node { result } - pub fn search_point(&self, point: i32) -> HashSet { + pub fn search_point(&self, point: i32) -> HashSet<&Interval> { let mut result = HashSet::new(); for interval in &self.s_center { if interval.contains_point(point) { - result.insert(interval.clone()); + result.insert(interval); } } if point < self.x_center { From 2cdaccf74cda0c4095666711c24ec341d17795ca Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 3 Feb 2024 11:54:23 +0100 Subject: [PATCH 14/52] Reimplement counting of reads for entire file --- src/main.rs | 164 ++++++++++++++++------------------------------------ 1 file changed, 49 insertions(+), 115 deletions(-) diff --git a/src/main.rs b/src/main.rs index f43b990..a27d0b5 100755 --- a/src/main.rs +++ b/src/main.rs @@ -37,7 +37,9 @@ fn main() { // Read the gtf file let gtf = read_gtf(&args.gtf, args.t.as_str()); - eprintln!("{:?}",gtf["1"].overlap(24646121, 24646123)); + // for overlap in gtf["1"].overlap(169680637, 169680637+25) { + // eprintln!("overlap: {:?}", overlap); + // } if args.export_feature_map.is_some() { let mut file = File::create(args.export_feature_map.clone().unwrap()).expect("Unable to create file"); @@ -47,8 +49,8 @@ fn main() { } } - // exit(1) to prevent the rest of the program from running - std::process::exit(1); + // exit(1) to prevent the rest of the program from running for debugging purposes + // std::process::exit(1); let mut counts = prepare_count_hashmap(>f); @@ -240,6 +242,8 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap = HashMap::new(); for (chr, intervals) in map { @@ -247,8 +251,7 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf_end_sorted: HashMap) { +fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf: HashMap) { for record in bam { + //eprintln!("{} records processed.", counter); *counter += 1; if *counter % 100000 == 0 { //println!("{} records processed.", counter); eprintln!("{} records processed.", counter); } let record = record.unwrap(); - if String::from_utf8_lossy(record.name())=="SRR001432.281211 USI-EAS21_0008_3445:8:7:657:535 length=25" { - //println!("{}: {}-{}", String::from_utf8_lossy(record.name()), record.start(), record.calculate_end()); - eprintln!("this one"); - } + // if String::from_utf8_lossy(record.name())=="SRR001432.281211 USI-EAS21_0008_3445:8:7:657:535 length=25" { + // //println!("{}: {}-{}", String::from_utf8_lossy(record.name()), record.start(), record.calculate_end()); + // eprintln!("this one"); + // } if should_skip_record(&record, counts, args) { continue; } // todo - unimplemented!("todo"); + //unimplemented!("todo"); let ref_id = record.ref_id(); let reference = &reference_names[ref_id as usize]; - if gtf_end_sorted.contains_key(reference) { - let start_pos: u32 = record.start().try_into().unwrap(); - let end_pos: u32 = record.calculate_end().try_into().unwrap(); - let features = >f_end_sorted[reference]; + if gtf.contains_key(reference) { + let start_pos = record.start().try_into().unwrap(); + let end_pos = record.calculate_end().try_into().unwrap(); + let features = >f[reference]; let mut ambiguous = false; - - //if String::from_utf8_lossy(record.name())=="SRR001432.153301 USI-EAS21_0008_3445:8:4:393:300 length=25" { - //println!("{}: {}-{}", String::from_utf8_lossy(record.name()), record.start(), record.calculate_end()); - //eprintln!("startindex: {}, endindex: {}", startindex, endindex); - //eprintln!("feature: {:?}", features.0[startindex]); - //std::process::exit(1); - //} // case 1: read is fully within feature -> count feature // RRR @@ -405,82 +402,45 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap1 { + feature_name = process_partial_read(&features, start_pos, end_pos, &mut ambiguous); + } else { + //todo!("cigar length > 1"); feature_name= String::default(); // construct partial reads for each cigar element with AlnMatch // keep track of feature_names for each partial read, if they are all the same, we can count the feature - let mut partial_reads: Vec<(u32, u32)> = Vec::new(); - let mut partial_read_feature_names: Vec = Vec::new(); - let mut start_pos = start_pos; + + // if cigar has length > 1, we need to check each cigar element for cig in cigar.iter() { if cig.1 != Operation::AlnMatch { // Skip all cigar elements that are not matches, but add the length to the start position - start_pos += cig.0; + start_pos += cig.0 as i32; continue; } - let partial_end_pos = start_pos + cig.0; - partial_reads.push((start_pos, partial_end_pos)); + let partial_end_pos = start_pos + cig.0 as i32; + let temp_feature_name = process_partial_read(features, start_pos, partial_end_pos, &mut ambiguous); // if ambiguous flag is set, we can stop here, otherwise we can add the feature name to the list if ambiguous { break; - } else { - partial_read_feature_names.push(temp_feature_name); - } - start_pos += cig.0; - } - // now check if all feature names are the same - if !ambiguous { - let first_feature_name = &partial_read_feature_names[0]; - if partial_read_feature_names.iter().all(|f| f == first_feature_name) { - feature_name = first_feature_name.clone(); - } else { + } else if feature_name != String::default() && feature_name != temp_feature_name { ambiguous = true; + break; + } + else { + feature_name = temp_feature_name; } + start_pos = partial_end_pos; } - - // if cigar has length > 1, we need to check each cigar element - // for cig in cigar.iter() { - // if cig.1 != Operation::AlnMatch { - // // Skip all cigar elements that are not matches, but add the length to the start position - // start_pos += cig.0; - // continue; - // } - // let partial_end_pos = start_pos + cig.0; - // if startindex < features.0.len() - // && current_feature.start <= partial_end_pos - // && current_feature.end >= start_pos - // { - // let feature_name = ¤t_feature.name; - // while startindex < features.0.len() { - // current_feature = >f_end_sorted[reference].0[startindex]; - // if current_feature.start > partial_end_pos { - // break; - // } - // // check if same feature name, otherwise ambiguous - // if feature_name != ¤t_feature.name { - // //println!("Ambiguous feature found! {}: {}:{}-{} (position: {}); (alternate: {}) (index: {})", map[&reference][index].name,reference, map[&reference][index].start, map[&reference][index].end, start_pos, feature_name, index); - // ambiguous = true; - // break; - // } - // //println!("Feature found! {}: {}:{}-{} (position: {})", map[&reference][index].name,reference, map[&reference][index].start, map[&reference][index].end, start_pos); - // feature_count = 1; - // startindex += 1; - // } - // } - // start_pos += cig.0; - // } } if ambiguous { *counts.entry("__ambiguous".to_string()).or_insert(0) += 1; - } else if feature_name == String::default() { + } else if *feature_name == String::default() { *counts.entry("__no_feature".to_string()).or_insert(0) += 1; } else { *counts.entry(feature_name.clone()).or_insert(0) += 1; @@ -494,46 +454,20 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap String { +fn process_partial_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool) -> String { let mut feature_name = String::default(); - todo!("process_partial_read"); - - feature_name -} -fn get_end_index(features: &[Feature], _start_pos: u32, end_pos: u32) -> usize{ - // find index of the first feature that starts after the read end - let endindex = match features.binary_search_by(|f| { - if f.start > end_pos { - std::cmp::Ordering::Greater - } else { - std::cmp::Ordering::Less - } - }) { - Ok(index) | Err(index) => { - //eprintln!("f.start>end_pos: {}, f.start: {}, end_pos: {}, index: {}, {}, feature:{:?}", features.len(), features[index].start, end_pos, index, features[index].start > end_pos, features[index]); - index + 1 - } - }; - endindex -} + let overlapping_features = features.overlap(start_pos-1, end_pos); -fn get_start_index(features: &Vec, start_pos: u32, _end_pos: u32) -> usize { - let startindex = match features.binary_search_by(|f| { - if f.end < start_pos { - std::cmp::Ordering::Less - } else { - std::cmp::Ordering::Greater - } - }) { - Ok(index) | Err(index) => { - //eprintln!("f.end 0 { - index - 1 - } else { - index - } - } - }; - features[startindex].end_sorted_index -} + if overlapping_features.len() == 0 { + return feature_name; + } else if overlapping_features.len() == 1 { + feature_name = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().name.clone(); + } else { + *ambiguous = true; + } + + //todo!("process_partial_read"); + + feature_name +} \ No newline at end of file From b5b9d1f154ac679a9882358b5a59ba7afde4d53d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:26:28 +0100 Subject: [PATCH 15/52] remove test output file --- test_out.txt | 26490 ------------------------------------------------- 1 file changed, 26490 deletions(-) delete mode 100755 test_out.txt diff --git a/test_out.txt b/test_out.txt deleted file mode 100755 index 71d0e9f..0000000 --- a/test_out.txt +++ /dev/null @@ -1,26490 +0,0 @@ -A1BG 232 -A1BG-AS1 70 -A1CF 0 -A2M 21428 -A2M-AS1 230 -A2ML1 181 -A2MP1 12 -A3GALT2 6 -A4GALT 728 -A4GNT 0 -AA06 0 -AAAS 1245 -AACS 658 -AACSP1 4 -AADAC 15 -AADACL2 0 -AADACL2-AS1 0 -AADACL3 1 -AADACL4 0 -AADACP1 5 -AADAT 390 -AAED1 161 -AAGAB 1153 -AAK1 8069 -AAMDC 230 -AAMP 2920 -AANAT 4 -AAR2 662 -AARD 16 -AARS 8037 -AARS2 713 -AARSD1 0 -AASDH 569 -AASDHPPT 1948 -AASS 1864 -AATBC 98 -AATF 0 -AATK 4157 -AATK-AS1 12 -ABALON 102 -ABAT 14481 -ABCA1 2452 -ABCA10 123 -ABCA11P 131 -ABCA12 9 -ABCA13 497 -ABCA17P 135 -ABCA2 15041 -ABCA3 5640 -ABCA4 21 -ABCA5 1521 -ABCA6 1065 -ABCA7 1743 -ABCA8 6182 -ABCA9 1937 -ABCA9-AS1 5 -ABCB1 2184 -ABCB10 312 -ABCB11 0 -ABCB4 41 -ABCB5 0 -ABCB6 1457 -ABCB7 497 -ABCB8 1806 -ABCB9 377 -ABCC1 118 -ABCC10 1019 -ABCC11 19 -ABCC12 1 -ABCC13 2 -ABCC2 68 -ABCC3 1412 -ABCC4 572 -ABCC5 3865 -ABCC5-AS1 3 -ABCC6 15 -ABCC6P1 11 -ABCC6P2 1 -ABCC8 938 -ABCC9 646 -ABCD1 659 -ABCD2 106 -ABCD3 1397 -ABCD4 1756 -ABCE1 946 -ABCF1 29 -ABCF2 2025 -ABCF3 1793 -ABCG1 700 -ABCG2 1312 -ABCG4 400 -ABCG5 14 -ABCG8 11 -ABHD1 56 -ABHD10 1359 -ABHD11 225 -ABHD11-AS1 3 -ABHD12 3157 -ABHD12B 51 -ABHD13 490 -ABHD14A 1241 -ABHD14A-ACY1 3 -ABHD14B 632 -ABHD15 357 -ABHD16A 881 -ABHD16B 251 -ABHD17A 533 -ABHD17B 609 -ABHD17C 634 -ABHD2 4622 -ABHD3 1765 -ABHD4 1634 -ABHD5 835 -ABHD6 1098 -ABHD8 2998 -ABI1 2404 -ABI2 6853 -ABI3 283 -ABI3BP 1029 -ABL1 5028 -ABL2 2277 -ABLIM1 9931 -ABLIM2 2332 -ABLIM3 3071 -ABO 169 -ABR 7 -ABRA 3 -ABRACL 177 -ABT1 352 -ABTB1 1322 -ABTB2 935 -ACAA1 2997 -ACAA2 1235 -ACACA 12 -ACACB 2742 -ACAD10 540 -ACAD11 87 -ACAD8 828 -ACAD9 934 -ACADL 471 -ACADM 1507 -ACADS 345 -ACADSB 812 -ACADVL 12048 -ACAN 1003 -ACAP1 269 -ACAP2 1530 -ACAP3 4822 -ACAT1 1321 -ACAT2 446 -ACBD3 1894 -ACBD4 786 -ACBD5 2240 -ACBD6 502 -ACBD7 1322 -ACCS 73 -ACCSL 0 -ACD 740 -ACE 213 -ACE2 6 -ACER1 8 -ACER2 320 -ACER3 1982 -ACHE 8023 -ACIN1 10246 -ACKR1 1077 -ACKR2 40 -ACKR3 519 -ACKR4 8 -ACLY 4132 -ACMSD 8 -ACO1 1666 -ACO2 2758 -ACOT1 66 -ACOT11 299 -ACOT12 10 -ACOT13 1369 -ACOT2 209 -ACOT4 82 -ACOT6 40 -ACOT7 3986 -ACOT8 698 -ACOT9 430 -ACOX1 2382 -ACOX2 476 -ACOX3 344 -ACOXL 7 -ACP1 1490 -ACP2 1022 -ACP5 122 -ACP6 291 -ACPP 18 -ACPT 3 -ACR 6 -ACRBP 79 -ACRC 1402 -ACRV1 7 -ACSBG1 1147 -ACSBG2 51 -ACSF2 412 -ACSF3 531 -ACSL1 2980 -ACSL3 2788 -ACSL4 2482 -ACSL5 846 -ACSL6 1303 -ACSM1 6 -ACSM2A 1 -ACSM2B 1 -ACSM3 5 -ACSM4 1 -ACSM5 205 -ACSM6 0 -ACSS1 1512 -ACSS2 1172 -ACSS3 400 -ACTA1 206 -ACTA2 1632 -ACTA2-AS1 4 -ACTB 36705 -ACTBL2 0 -ACTC1 120 -ACTG1 25680 -ACTG1P17 33 -ACTG1P20 102 -ACTG1P4 56 -ACTG2 188 -ACTL10 21 -ACTL6A 527 -ACTL6B 738 -ACTL7A 0 -ACTL7B 0 -ACTL8 1 -ACTL9 0 -ACTN1 5160 -ACTN1-AS1 2 -ACTN2 424 -ACTN3 20 -ACTN4 13972 -ACTR10 1738 -ACTR1A 5740 -ACTR1B 2168 -ACTR2 3966 -ACTR3 3667 -ACTR3B 588 -ACTR3BP2 0 -ACTR3BP5 0 -ACTR3C 36 -ACTR5 240 -ACTR6 771 -ACTR8 807 -ACTRT1 1 -ACTRT2 0 -ACTRT3 730 -ACVR1 645 -ACVR1B 1596 -ACVR1C 845 -ACVR2A 685 -ACVR2B 843 -ACVR2B-AS1 30 -ACVRL1 597 -ACY1 18 -ACY3 44 -ACYP1 634 -ACYP2 1435 -ADA 109 -ADAD1 0 -ADAD2 36 -ADAL 615 -ADAM10 1937 -ADAM11 553 -ADAM12 236 -ADAM15 1853 -ADAM17 1265 -ADAM18 0 -ADAM19 389 -ADAM1A 212 -ADAM2 0 -ADAM20 18 -ADAM20P1 105 -ADAM21 23 -ADAM21P1 3 -ADAM22 2206 -ADAM23 1315 -ADAM28 345 -ADAM29 6 -ADAM30 0 -ADAM32 5 -ADAM33 1764 -ADAM3A 0 -ADAM5 0 -ADAM6 0 -ADAM7 0 -ADAM8 296 -ADAM9 837 -ADAMDEC1 2 -ADAMTS1 3439 -ADAMTS10 1713 -ADAMTS12 16 -ADAMTS13 504 -ADAMTS14 17 -ADAMTS15 80 -ADAMTS16 17 -ADAMTS17 254 -ADAMTS18 171 -ADAMTS19 40 -ADAMTS19-AS1 1 -ADAMTS2 224 -ADAMTS20 3 -ADAMTS3 85 -ADAMTS4 194 -ADAMTS5 112 -ADAMTS6 120 -ADAMTS7 100 -ADAMTS7P1 30 -ADAMTS8 256 -ADAMTS9 1148 -ADAMTS9-AS1 38 -ADAMTS9-AS2 132 -ADAMTSL1 747 -ADAMTSL2 733 -ADAMTSL3 313 -ADAMTSL4 422 -ADAMTSL4-AS1 28 -ADAMTSL5 105 -ADAP1 1871 -ADAP2 336 -ADAR 10250 -ADARB1 2033 -ADARB2 1232 -ADARB2-AS1 3 -ADAT1 587 -ADAT2 157 -ADAT3 223 -ADCK1 272 -ADCK2 1054 -ADCK3 1197 -ADCK4 1121 -ADCK5 317 -ADCY1 1487 -ADCY10 41 -ADCY10P1 371 -ADCY2 4728 -ADCY3 1239 -ADCY4 478 -ADCY5 3211 -ADCY6 2934 -ADCY7 2512 -ADCY8 859 -ADCY9 1560 -ADCYAP1 1081 -ADCYAP1R1 11001 -ADD1 11559 -ADD2 894 -ADD3 6265 -ADD3-AS1 34 -ADGB 100 -ADGRA1 1584 -ADGRA1-AS1 18 -ADGRA2 1417 -ADGRA3 2589 -ADGRB1 4335 -ADGRB2 3663 -ADGRB3 1362 -ADGRD1 277 -ADGRE1 23 -ADGRE2 125 -ADGRE3 0 -ADGRE4P 24 -ADGRE5 286 -ADGRF1 1 -ADGRF2 2 -ADGRF3 56 -ADGRF4 57 -ADGRF5 1874 -ADGRG1 5776 -ADGRG2 45 -ADGRG3 7 -ADGRG4 1 -ADGRG5 26 -ADGRG6 294 -ADGRG7 0 -ADGRL1 8168 -ADGRL2 4100 -ADGRL3 1647 -ADGRL3-AS1 3 -ADGRL4 776 -ADGRV1 5677 -ADH1A 3 -ADH1B 298 -ADH1C 10 -ADH4 2 -ADH5 2079 -ADH6 8 -ADH7 0 -ADHFE1 348 -ADI1 412 -ADIG 0 -ADIPOQ 19 -ADIPOQ-AS1 0 -ADIPOR1 2884 -ADIPOR2 4897 -ADIRF 2856 -ADK 599 -ADM 564 -ADM2 44 -ADM5 211 -ADNP 4341 -ADNP-AS1 134 -ADNP2 1062 -ADO 867 -ADORA1 834 -ADORA2A 42 -ADORA2A-AS1 98 -ADORA2B 101 -ADORA3 232 -ADPGK 1109 -ADPGK-AS1 17 -ADPRH 285 -ADPRHL1 280 -ADPRHL2 1019 -ADPRM 151 -ADRA1A 217 -ADRA1B 257 -ADRA1D 53 -ADRA2A 495 -ADRA2B 123 -ADRA2C 466 -ADRB1 204 -ADRB2 121 -ADRB3 16 -ADRBK1 6438 -ADRBK2 1480 -ADRM1 2694 -ADSL 503 -ADSS 818 -ADSSL1 262 -ADTRP 9 -AEBP1 28569 -AEBP2 1445 -AEN 672 -AES 19501 -AFAP1 944 -AFAP1-AS1 22 -AFAP1L1 393 -AFAP1L2 1820 -AFF1 4962 -AFF2 973 -AFF3 1576 -AFF4 6395 -AFG3L1P 1062 -AFG3L2 738 -AFM 0 -AFMID 311 -AFP 7 -AFTPH 2799 -AGA 490 -AGAP1 5283 -AGAP1-IT1 6 -AGAP11 171 -AGAP2 3576 -AGAP2-AS1 97 -AGAP3 7797 -AGAP4 35 -AGAP5 91 -AGAP6 235 -AGAP7P 81 -AGAP9 128 -AGBL1 12 -AGBL1-AS1 1 -AGBL2 173 -AGBL3 48 -AGBL4 138 -AGBL4-IT1 0 -AGBL5 988 -AGBL5-AS1 1 -AGER 121 -AGFG1 2105 -AGFG2 2593 -AGGF1 1279 -AGK 79 -AGL 644 -AGMAT 130 -AGMO 6 -AGO1 1120 -AGO2 707 -AGO3 576 -AGO4 1154 -AGPAT1 0 -AGPAT2 756 -AGPAT3 5165 -AGPAT4 2593 -AGPAT4-IT1 275 -AGPAT5 1879 -AGPS 912 -AGR2 0 -AGR3 4 -AGRN 3476 -AGRP 3316 -AGT 5738 -AGTPBP1 759 -AGTR1 375 -AGTR2 0 -AGTRAP 500 -AGXT 0 -AGXT2 14 -AHCTF1 1336 -AHCTF1P1 210 -AHCY 2000 -AHCYL1 14515 -AHCYL2 4497 -AHDC1 4594 -AHI1 3580 -AHNAK 30854 -AHNAK2 2494 -AHR 1097 -AHRR 81 -AHSA1 11893 -AHSA2 6952 -AHSG 0 -AHSP 0 -AICDA 0 -AIDA 351 -AIF1 5 -AIF1L 4565 -AIFM1 579 -AIFM2 786 -AIFM3 1036 -AIG1 1917 -AIM1 158 -AIM1L 4 -AIM2 34 -AIMP1 1300 -AIMP2 157 -AIP 1965 -AIPL1 4 -AIRE 175 -AIRN 20 -AJAP1 390 -AJUBA 508 -AK1 5509 -AK2 1819 -AK3 3168 -AK4 1226 -AK5 1563 -AK6 0 -AK7 329 -AK8 134 -AK9 636 -AKAP1 1607 -AKAP10 1109 -AKAP11 4615 -AKAP12 9641 -AKAP13 5128 -AKAP14 32 -AKAP17A 94 -AKAP2 6 -AKAP3 129 -AKAP4 0 -AKAP5 191 -AKAP6 3772 -AKAP7 740 -AKAP8 1155 -AKAP8L 4247 -AKAP9 8226 -AKIP1 416 -AKIRIN1 3814 -AKIRIN2 2225 -AKNA 1922 -AKNAD1 25 -AKR1A1 826 -AKR1B1 2371 -AKR1B10 4 -AKR1B15 0 -AKR1C1 596 -AKR1C2 520 -AKR1C3 705 -AKR1C4 2 -AKR1C6P 5 -AKR1C8P 0 -AKR1D1 0 -AKR1E2 61 -AKR7A2 1292 -AKR7A2P1 8 -AKR7A3 36 -AKR7L 192 -AKT1 4470 -AKT1S1 2601 -AKT2 3777 -AKT3 1 -AKTIP 1501 -ALAD 4412 -ALAS1 938 -ALAS2 6 -ALB 23 -ALCAM 3601 -ALDH16A1 616 -ALDH18A1 1106 -ALDH1A1 471 -ALDH1A2 197 -ALDH1A3 124 -ALDH1B1 183 -ALDH1L1 1374 -ALDH1L1-AS1 3 -ALDH1L1-AS2 109 -ALDH1L2 616 -ALDH2 8127 -ALDH3A1 34 -ALDH3A2 2634 -ALDH3B1 190 -ALDH3B2 3 -ALDH4A1 1195 -ALDH5A1 2820 -ALDH6A1 3922 -ALDH7A1 2011 -ALDH8A1 135 -ALDH9A1 3012 -ALDOA 30093 -ALDOB 22 -ALDOC 10465 -ALG1 217 -ALG10 45 -ALG10B 274 -ALG11 103 -ALG12 623 -ALG13 1111 -ALG14 235 -ALG1L 9 -ALG1L2 0 -ALG1L9P 67 -ALG2 1437 -ALG3 392 -ALG5 387 -ALG6 195 -ALG8 636 -ALG9 578 -ALK 829 -ALKBH1 424 -ALKBH2 287 -ALKBH3 292 -ALKBH3-AS1 11 -ALKBH4 371 -ALKBH5 6383 -ALKBH6 524 -ALKBH7 902 -ALKBH8 267 -ALLC 14 -ALMS1 1098 -ALMS1-IT1 18 -ALMS1P 68 -ALOX12 87 -ALOX12-AS1 80 -ALOX12B 9 -ALOX12P2 126 -ALOX15 157 -ALOX15B 46 -ALOX15P1 12 -ALOX5 0 -ALOX5AP 339 -ALOXE3 56 -ALPI 0 -ALPK1 729 -ALPK2 57 -ALPK3 1275 -ALPL 1587 -ALPP 3 -ALPPL2 0 -ALS2 1549 -ALS2CL 771 -ALS2CR11 37 -ALS2CR12 196 -ALX1 6 -ALX3 130 -ALX4 57 -ALYREF 859 -AMACR 45 -AMBN 16 -AMBP 2 -AMBRA1 1666 -AMD1 3066 -AMDHD1 30 -AMDHD2 213 -AMELX 1 -AMELY 0 -AMER1 501 -AMER2 2426 -AMER3 657 -AMFR 5044 -AMH 425 -AMHR2 13 -AMICA1 74 -AMIGO1 447 -AMIGO2 1121 -AMIGO3 741 -AMMECR1 179 -AMMECR1L 1094 -AMN 26 -AMN1 771 -AMOT 1808 -AMOTL1 3615 -AMOTL2 2530 -AMPD1 10 -AMPD2 4116 -AMPD3 847 -AMPH 1936 -AMT 521 -AMTN 0 -AMY1A 0 -AMY1B 0 -AMY1C 0 -AMY2A 0 -AMY2B 551 -AMZ1 184 -AMZ2 2233 -AMZ2P1 731 -ANAPC1 268 -ANAPC10 270 -ANAPC11 1186 -ANAPC13 1600 -ANAPC15 116 -ANAPC16 4547 -ANAPC1P1 7 -ANAPC2 1304 -ANAPC4 472 -ANAPC5 2405 -ANAPC7 1472 -ANG 149 -ANGEL1 1369 -ANGEL2 923 -ANGPT1 594 -ANGPT2 520 -ANGPT4 5 -ANGPTL1 654 -ANGPTL2 367 -ANGPTL3 4 -ANGPTL4 1277 -ANGPTL5 16 -ANGPTL6 25 -ANGPTL7 50 -ANHX 1 -ANK1 624 -ANK2 14128 -ANK3 3114 -ANKAR 210 -ANKDD1A 647 -ANKDD1B 60 -ANKEF1 242 -ANKFN1 212 -ANKFY1 3989 -ANKH 3768 -ANKHD1 271 -ANKHD1-EIF4EBP3 67 -ANKIB1 3290 -ANKK1 122 -ANKLE1 166 -ANKLE2 2350 -ANKMY1 214 -ANKMY2 932 -ANKRA2 342 -ANKRD1 2 -ANKRD10 3519 -ANKRD11 10819 -ANKRD12 10044 -ANKRD13A 860 -ANKRD13B 1756 -ANKRD13C 740 -ANKRD13D 2643 -ANKRD16 360 -ANKRD17 7009 -ANKRD18A 259 -ANKRD18B 71 -ANKRD18DP 0 -ANKRD19P 581 -ANKRD2 71 -ANKRD20A1 0 -ANKRD20A11P 42 -ANKRD20A12P 7 -ANKRD20A19P 56 -ANKRD20A2 0 -ANKRD20A3 0 -ANKRD20A4 73 -ANKRD20A5P 53 -ANKRD20A8P 202 -ANKRD20A9P 0 -ANKRD22 15 -ANKRD23 268 -ANKRD24 899 -ANKRD26 2593 -ANKRD26P1 27 -ANKRD26P3 21 -ANKRD27 1289 -ANKRD28 1432 -ANKRD29 475 -ANKRD30A 2 -ANKRD30B 53 -ANKRD30BL 27 -ANKRD30BP2 1 -ANKRD30BP3 1 -ANKRD31 22 -ANKRD33 0 -ANKRD33B 234 -ANKRD34A 725 -ANKRD34B 374 -ANKRD34C 268 -ANKRD34C-AS1 8 -ANKRD35 688 -ANKRD36 422 -ANKRD36B 315 -ANKRD36BP1 210 -ANKRD36BP2 85 -ANKRD36C 1020 -ANKRD37 522 -ANKRD39 276 -ANKRD40 6372 -ANKRD42 2050 -ANKRD44 885 -ANKRD44-IT1 11 -ANKRD45 434 -ANKRD46 1319 -ANKRD49 382 -ANKRD50 738 -ANKRD52 4344 -ANKRD53 125 -ANKRD54 1349 -ANKRD55 201 -ANKRD6 1109 -ANKRD60 5 -ANKRD61 33 -ANKRD62 4 -ANKRD62P1-PARP4P3 20 -ANKRD63 11 -ANKRD65 352 -ANKRD66 16 -ANKRD7 10 -ANKRD9 532 -ANKS1A 2176 -ANKS1B 2639 -ANKS3 1170 -ANKS4B 3 -ANKS6 1076 -ANKUB1 13 -ANKZF1 1312 -ANLN 1548 -ANO1 116 -ANO1-AS2 1 -ANO10 833 -ANO2 186 -ANO3 87 -ANO4 82 -ANO5 781 -ANO6 2760 -ANO7 108 -ANO8 2571 -ANO9 47 -ANOS1 824 -ANP32A 2912 -ANP32A-IT1 89 -ANP32AP1 46 -ANP32B 5963 -ANP32C 69 -ANP32D 7 -ANP32E 3501 -ANPEP 79 -ANTXR1 9110 -ANTXR2 1058 -ANTXRL 5 -ANTXRLP1 1 -ANXA1 10009 -ANXA10 0 -ANXA11 2125 -ANXA13 8 -ANXA2 3002 -ANXA2P1 7 -ANXA2P2 19 -ANXA2P3 17 -ANXA2R 56 -ANXA3 217 -ANXA4 686 -ANXA5 6321 -ANXA6 6678 -ANXA7 2193 -ANXA8 1 -ANXA8L1 0 -ANXA9 359 -AOAH 236 -AOAH-IT1 1 -AOC1 11 -AOC2 304 -AOC3 302 -AOC4P 6 -AOX1 172 -AOX2P 0 -AP1AR 466 -AP1B1 4610 -AP1B1P1 0 -AP1G1 2765 -AP1G2 1590 -AP1M1 1827 -AP1M2 7 -AP1S1 1353 -AP1S2 1464 -AP1S3 240 -AP2A1 4381 -AP2A2 310 -AP2B1 11175 -AP2M1 12186 -AP2S1 2023 -AP3B1 1447 -AP3B2 2386 -AP3D1 9883 -AP3M1 1675 -AP3M2 1781 -AP3S1 1327 -AP3S2 27 -AP4B1 1124 -AP4B1-AS1 179 -AP4E1 695 -AP4M1 496 -AP4S1 817 -AP5B1 1165 -AP5M1 1095 -AP5S1 337 -AP5Z1 1332 -APAF1 586 -APBA1 441 -APBA2 85 -APBA3 781 -APBB1 6420 -APBB1IP 795 -APBB2 2027 -APBB3 1046 -APC 7005 -APC2 11791 -APCDD1 1732 -APCDD1L 3 -APCDD1L-AS1 1 -APCS 0 -APEH 1378 -APELA 0 -APEX1 1580 -APEX2 458 -APH1A 1372 -APH1B 807 -API5 1563 -APIP 818 -APITD1 145 -APITD1-CORT 6 -APLF 57 -APLN 531 -APLNR 4215 -APLP1 16691 -APLP2 18782 -APMAP 3596 -APOA1 44 -APOA1-AS 31 -APOA1BP 1566 -APOA2 1 -APOA4 0 -APOA5 0 -APOB 42 -APOBEC1 0 -APOBEC2 33 -APOBEC3A 4 -APOBEC3A_B 0 -APOBEC3B 4 -APOBEC3B-AS1 0 -APOBEC3C 201 -APOBEC3D 69 -APOBEC3F 149 -APOBEC3G 102 -APOBEC3H 9 -APOBEC4 6 -APOBR 293 -APOC1 1055 -APOC1P1 54 -APOC2 0 -APOC3 0 -APOC4 0 -APOC4-APOC2 6 -APOD 15833 -APOE 53188 -APOF 15 -APOH 4 -APOL1 1287 -APOL2 2126 -APOL3 768 -APOL4 609 -APOL5 0 -APOL6 2677 -APOLD1 1328 -APOM 11 -APOO 700 -APOOL 988 -APOOP5 2 -APOPT1 952 -APP 40733 -APPBP2 2368 -APPL1 1842 -APPL2 1416 -APRT 541 -APTR 499 -APTX 931 -AQP1 12638 -AQP10 0 -AQP11 174 -AQP12A 1 -AQP12B 0 -AQP2 1 -AQP3 141 -AQP4 25680 -AQP4-AS1 189 -AQP5 83 -AQP6 34 -AQP7 24 -AQP7P1 8 -AQP7P3 7 -AQP8 13 -AQP9 21 -AQR 835 -AR 2674 -ARAF 1154 -ARAP1 5026 -ARAP2 3093 -ARAP3 1015 -ARC 4102 -ARCN1 4844 -AREG 22 -AREL1 1144 -ARF1 13185 -ARF3 12866 -ARF4 4105 -ARF5 2227 -ARF6 1803 -ARFGAP1 2928 -ARFGAP2 1941 -ARFGAP3 1694 -ARFGEF1 1633 -ARFGEF2 2284 -ARFGEF3 4316 -ARFIP1 865 -ARFIP2 1847 -ARFRP1 1101 -ARG1 4 -ARG2 1896 -ARGFX 0 -ARGFXP2 23 -ARGLU1 4830 -ARHGAP1 1832 -ARHGAP10 368 -ARHGAP11A 1 -ARHGAP11B 0 -ARHGAP12 2248 -ARHGAP15 128 -ARHGAP17 2089 -ARHGAP18 666 -ARHGAP19 327 -ARHGAP19-SLIT1 3 -ARHGAP20 338 -ARHGAP21 5807 -ARHGAP22 575 -ARHGAP23 122 -ARHGAP24 1054 -ARHGAP25 217 -ARHGAP26 3685 -ARHGAP26-AS1 1 -ARHGAP26-IT1 6 -ARHGAP27 4 -ARHGAP28 54 -ARHGAP29 860 -ARHGAP30 497 -ARHGAP31 2268 -ARHGAP31-AS1 12 -ARHGAP32 3384 -ARHGAP33 2443 -ARHGAP35 10757 -ARHGAP36 5639 -ARHGAP39 1883 -ARHGAP4 1015 -ARHGAP40 6 -ARHGAP42 341 -ARHGAP44 1967 -ARHGAP5 7980 -ARHGAP5-AS1 266 -ARHGAP6 1407 -ARHGAP8 0 -ARHGAP9 586 -ARHGDIA 13115 -ARHGDIB 1552 -ARHGDIG 2799 -ARHGEF1 2657 -ARHGEF10 14 -ARHGEF10L 2627 -ARHGEF11 3820 -ARHGEF12 8475 -ARHGEF15 211 -ARHGEF16 95 -ARHGEF17 5919 -ARHGEF18 1880 -ARHGEF19 130 -ARHGEF2 3023 -ARHGEF25 2412 -ARHGEF26 237 -ARHGEF26-AS1 499 -ARHGEF28 509 -ARHGEF3 2788 -ARHGEF3-AS1 1 -ARHGEF33 234 -ARHGEF34P 91 -ARHGEF35 26 -ARHGEF37 2067 -ARHGEF38 7 -ARHGEF38-IT1 0 -ARHGEF39 38 -ARHGEF4 6604 -ARHGEF40 2969 -ARHGEF5 121 -ARHGEF6 3071 -ARHGEF7 3988 -ARHGEF7-AS1 1 -ARHGEF7-AS2 28 -ARHGEF9 4742 -ARHGEF9-IT1 0 -ARID1A 6322 -ARID1B 3553 -ARID2 1343 -ARID3A 202 -ARID3B 236 -ARID3C 9 -ARID4A 3336 -ARID4B 4470 -ARID5A 2214 -ARID5B 3802 -ARIH1 2284 -ARIH2 2289 -ARIH2OS 47 -ARL1 2526 -ARL10 310 -ARL11 25 -ARL13A 3 -ARL13B 663 -ARL14 0 -ARL14EP 871 -ARL14EPL 5 -ARL15 398 -ARL16 249 -ARL17A 22 -ARL17B 0 -ARL2 1972 -ARL2-SNX15 0 -ARL2BP 2273 -ARL3 2523 -ARL4A 303 -ARL4C 3335 -ARL4D 154 -ARL5A 1735 -ARL5B 288 -ARL5C 0 -ARL6 286 -ARL6IP1 8298 -ARL6IP4 5027 -ARL6IP5 5437 -ARL6IP6 595 -ARL8A 4227 -ARL8B 3917 -ARL9 72 -ARMC1 1203 -ARMC10 270 -ARMC12 186 -ARMC2 409 -ARMC2-AS1 3 -ARMC3 596 -ARMC4 104 -ARMC5 1129 -ARMC6 867 -ARMC7 447 -ARMC8 1319 -ARMC9 1404 -ARMCX1 1399 -ARMCX2 2707 -ARMCX3 3811 -ARMCX4 1403 -ARMCX5 159 -ARMCX5-GPRASP2 30 -ARMCX6 327 -ARMS2 11 -ARMT1 590 -ARNT 1542 -ARNT2 7492 -ARNTL 1353 -ARNTL2 372 -ARNTL2-AS1 0 -ARPC1A 3244 -ARPC1B 1524 -ARPC2 4469 -ARPC3 1522 -ARPC4 2214 -ARPC4-TTLL3 0 -ARPC5 2239 -ARPC5L 1192 -ARPIN 1308 -ARPP19 7696 -ARPP21 592 -ARR3 1 -ARRB1 4631 -ARRB2 2889 -ARRDC1 742 -ARRDC1-AS1 635 -ARRDC2 1496 -ARRDC3 1512 -ARRDC3-AS1 24 -ARRDC4 5229 -ARRDC5 12 -ARSA 1733 -ARSB 356 -ARSD 561 -ARSE 241 -ARSF 18 -ARSG 121 -ARSH 1 -ARSI 96 -ARSJ 349 -ARSK 395 -ART1 5 -ART3 217 -ART4 7 -ART5 14 -ARTN 22 -ARV1 781 -ARVCF 1486 -ARX 92 -AS3MT 5 -ASAH1 5638 -ASAH2 8 -ASAH2B 2 -ASAP1 2998 -ASAP1-IT1 32 -ASAP1-IT2 137 -ASAP2 1525 -ASAP3 1497 -ASB1 2314 -ASB10 0 -ASB11 1 -ASB12 3 -ASB13 443 -ASB14 113 -ASB15 5 -ASB16 69 -ASB16-AS1 135 -ASB17 1 -ASB18 4 -ASB2 0 -ASB3 449 -ASB4 64 -ASB5 13 -ASB6 1571 -ASB7 494 -ASB8 1290 -ASB9 11 -ASB9P1 39 -ASCC1 1377 -ASCC2 1381 -ASCC3 1071 -ASCL1 563 -ASCL2 25 -ASCL3 6 -ASCL4 2 -ASCL5 29 -ASF1A 936 -ASF1B 13 -ASGR1 199 -ASGR2 21 -ASH1L 5658 -ASH1L-AS1 59 -ASH2L 1127 -ASIC1 1232 -ASIC2 409 -ASIC3 679 -ASIC4 234 -ASIC5 0 -ASIP 16 -ASL 544 -ASMT 0 -ASMTL 6 -ASMTL-AS1 31 -ASNA1 1884 -ASNS 2532 -ASNSD1 1446 -ASPA 256 -ASPDH 478 -ASPG 26 -ASPH 5357 -ASPHD1 959 -ASPHD2 542 -ASPM 12 -ASPN 95 -ASPRV1 362 -ASPSCR1 902 -ASRGL1 1802 -ASS1 1268 -ASTE1 182 -ASTL 9 -ASTN1 3798 -ASTN2 2411 -ASTN2-AS1 0 -ASUN 711 -ASXL1 2995 -ASXL2 988 -ASXL3 222 -ASZ1 0 -ATAD1 1303 -ATAD2 935 -ATAD2B 671 -ATAD3A 511 -ATAD3B 533 -ATAD3C 220 -ATAD5 235 -ATAT1 5 -ATCAY 7144 -ATE1 1203 -ATE1-AS1 172 -ATF1 728 -ATF2 2875 -ATF3 4488 -ATF4 9553 -ATF5 842 -ATF6 1672 -ATF6B 96 -ATF7 2151 -ATF7IP 3253 -ATF7IP2 464 -ATG10 220 -ATG101 1064 -ATG12 1720 -ATG13 3322 -ATG14 831 -ATG16L1 973 -ATG16L2 997 -ATG2A 1624 -ATG2B 1765 -ATG3 1467 -ATG4A 527 -ATG4B 2495 -ATG4C 545 -ATG4D 647 -ATG5 1002 -ATG7 484 -ATG9A 2849 -ATG9B 253 -ATHL1 1392 -ATIC 1402 -ATL1 1183 -ATL2 1222 -ATL3 2356 -ATM 4209 -ATMIN 2119 -ATN1 33133 -ATOH1 0 -ATOH7 8 -ATOH8 2905 -ATOX1 984 -ATP10A 984 -ATP10B 86 -ATP10D 1053 -ATP11A 2274 -ATP11A-AS1 27 -ATP11AUN 1 -ATP11B 1349 -ATP11C 603 -ATP12A 4 -ATP13A1 2710 -ATP13A2 7354 -ATP13A3 1437 -ATP13A4 2087 -ATP13A4-AS1 17 -ATP13A5 67 -ATP13A5-AS1 2 -ATP1A1 13238 -ATP1A1-AS1 124 -ATP1A2 29511 -ATP1A3 25367 -ATP1A4 175 -ATP1B1 11450 -ATP1B2 20081 -ATP1B3 3249 -ATP1B4 3 -ATP2A1 129 -ATP2A1-AS1 38 -ATP2A2 13359 -ATP2A3 279 -ATP2B1 3690 -ATP2B2 2212 -ATP2B2-IT2 1 -ATP2B3 1061 -ATP2B4 6362 -ATP2C1 4775 -ATP2C2 210 -ATP4A 1 -ATP4B 10 -ATP5A1 5942 -ATP5B 10197 -ATP5C1 1689 -ATP5D 3023 -ATP5E 316 -ATP5EP2 8 -ATP5F1 1863 -ATP5G1 739 -ATP5G2 3020 -ATP5G3 2466 -ATP5H 2246 -ATP5I 2344 -ATP5J 1958 -ATP5J2 1859 -ATP5J2-PTCD1 0 -ATP5L 2782 -ATP5L2 7 -ATP5O 2292 -ATP5S 315 -ATP5SL 1103 -ATP6AP1 5920 -ATP6AP1L 260 -ATP6AP2 4549 -ATP6V0A1 9906 -ATP6V0A2 776 -ATP6V0A4 9 -ATP6V0B 4010 -ATP6V0C 15188 -ATP6V0CP3 7 -ATP6V0D1 5508 -ATP6V0D2 1 -ATP6V0E1 2849 -ATP6V0E2 6647 -ATP6V0E2-AS1 197 -ATP6V1A 5776 -ATP6V1B1 38 -ATP6V1B1-AS1 10 -ATP6V1B2 6138 -ATP6V1C1 3983 -ATP6V1C2 120 -ATP6V1D 3405 -ATP6V1E1 3595 -ATP6V1E2 136 -ATP6V1F 3045 -ATP6V1G1 3008 -ATP6V1G2 28 -ATP6V1G2-DDX39B 3 -ATP6V1G3 0 -ATP6V1H 2329 -ATP7A 487 -ATP7B 516 -ATP8A1 2968 -ATP8A2 346 -ATP8B1 228 -ATP8B2 2579 -ATP8B3 38 -ATP8B4 149 -ATP8B5P 2 -ATP9A 7894 -ATP9B 481 -ATPAF1 1729 -ATPAF2 362 -ATPIF1 3881 -ATR 771 -ATRAID 1736 -ATRIP 168 -ATRN 2784 -ATRNL1 906 -ATRX 11331 -ATXN1 3252 -ATXN10 2794 -ATXN1L 1757 -ATXN2 3320 -ATXN2L 8419 -ATXN3 1019 -ATXN3L 0 -ATXN7 1442 -ATXN7L1 593 -ATXN7L2 556 -ATXN7L3 3595 -ATXN7L3B 4876 -ATXN8OS 18 -AUH 519 -AUNIP 43 -AUP1 4847 -AURKA 14 -AURKAIP1 2306 -AURKAPS1 99 -AURKB 4 -AURKC 59 -AUTS2 3430 -AVEN 642 -AVIL 907 -AVL9 1848 -AVP 35859 -AVPI1 524 -AVPR1A 208 -AVPR1B 2 -AVPR2 11 -AWAT1 0 -AWAT2 1 -AXDND1 22 -AXIN1 1560 -AXIN2 768 -AXL 2017 -AZGP1 80 -AZGP1P1 0 -AZI2 2238 -AZIN1 4801 -AZIN1-AS1 84 -AZIN2 449 -AZU1 0 -B2M 1721 -B3GALNT1 1451 -B3GALNT2 929 -B3GALT1 215 -B3GALT2 317 -B3GALT4 1 -B3GALT5 73 -B3GALT5-AS1 204 -B3GALT6 774 -B3GAT1 3763 -B3GAT2 121 -B3GAT3 2362 -B3GLCT 432 -B3GNT2 440 -B3GNT3 2 -B3GNT4 102 -B3GNT5 971 -B3GNT6 5 -B3GNT7 199 -B3GNT8 43 -B3GNT9 623 -B3GNTL1 25 -B4GALNT1 1677 -B4GALNT2 2 -B4GALNT3 198 -B4GALNT4 5548 -B4GALT1 1021 -B4GALT1-AS1 17 -B4GALT2 2285 -B4GALT3 1153 -B4GALT4 591 -B4GALT4-AS1 1 -B4GALT5 2351 -B4GALT6 677 -B4GALT7 657 -B4GAT1 10543 -B9D1 366 -B9D2 212 -BAALC 6673 -BAALC-AS1 42 -BAALC-AS2 30 -BAAT 1 -BABAM1 1738 -BACE1 2785 -BACE1-AS 101 -BACE2 761 -BACH1 854 -BACH1-IT2 3 -BACH2 556 -BAD 1852 -BAG1 2174 -BAG2 840 -BAG3 47961 -BAG4 1007 -BAG5 1622 -BAG6 2 -BAGE 0 -BAGE2 0 -BAGE3 0 -BAGE4 0 -BAGE5 0 -BAHCC1 1996 -BAHD1 2015 -BAIAP2 5010 -BAIAP2-AS1 2052 -BAIAP2L1 170 -BAIAP2L2 333 -BAIAP3 20980 -BAK1 149 -BAMBI 1012 -BANCR 0 -BANF1 1545 -BANF2 0 -BANK1 125 -BANP 1182 -BAP1 2778 -BARD1 223 -BARHL1 22 -BARHL2 24 -BARX1 39 -BARX2 42 -BASP1 11160 -BASP1P1 2 -BATF 38 -BATF2 222 -BATF3 80 -BAX 713 -BAZ1A 1414 -BAZ1B 5200 -BAZ2A 6809 -BAZ2B 5234 -BBC3 197 -BBIP1 396 -BBOX1 327 -BBOX1-AS1 10 -BBS1 2319 -BBS10 849 -BBS12 357 -BBS2 2244 -BBS4 608 -BBS5 604 -BBS7 699 -BBS9 830 -BBX 5131 -BCAM 3737 -BCAN 7516 -BCAP29 1461 -BCAP31 4045 -BCAR1 3945 -BCAR3 1553 -BCAR4 6 -BCAS1 7238 -BCAS2 1121 -BCAS3 923 -BCAS4 261 -BCAT1 1062 -BCAT2 1281 -BCCIP 1648 -BCDIN3D 241 -BCDIN3D-AS1 149 -BCHE 237 -BCKDHA 803 -BCKDHB 538 -BCKDK 1070 -BCL10 589 -BCL11A 266 -BCL11B 382 -BCL2 2240 -BCL2A1 41 -BCL2L1 4333 -BCL2L10 77 -BCL2L11 732 -BCL2L12 177 -BCL2L13 2331 -BCL2L14 1 -BCL2L15 39 -BCL2L2 5818 -BCL2L2-PABPN1 0 -BCL3 1948 -BCL6 12763 -BCL6B 605 -BCL7A 736 -BCL7B 2401 -BCL7C 1095 -BCL9 1500 -BCL9L 2800 -BCLAF1 2882 -BCO1 77 -BCO2 1161 -BCOR 1292 -BCORL1 1029 -BCORP1 0 -BCR 3316 -BCRP2 14 -BCRP3 71 -BCS1L 555 -BCYRN1 46 -BDH1 59 -BDH2 1083 -BDKRB1 1 -BDKRB2 61 -BDNF 155 -BDNF-AS 126 -BDP1 7 -BEAN1 148 -BEAN1-AS1 10 -BECN1 723 -BECN2 1 -BEGAIN 1384 -BEND2 0 -BEND3 146 -BEND3P3 591 -BEND4 346 -BEND5 345 -BEND6 688 -BEND7 522 -BEST1 430 -BEST2 26 -BEST3 37 -BEST4 168 -BET1 536 -BET1L 1615 -BEX1 8150 -BEX2 2769 -BEX4 7760 -BEX5 1971 -BFAR 5 -BFSP1 64 -BFSP2 3 -BGLAP 14 -BGLT3 0 -BGN 3707 -BHLHA15 27 -BHLHA9 5 -BHLHB9 1172 -BHLHE22 339 -BHLHE23 0 -BHLHE40 3244 -BHLHE40-AS1 47 -BHLHE41 2971 -BHMG1 2 -BHMT 46 -BHMT2 1112 -BICC1 535 -BICD1 556 -BICD2 2071 -BID 1316 -BIK 14 -BIN1 6266 -BIN2 148 -BIN3 626 -BIN3-IT1 60 -BIRC2 1881 -BIRC3 822 -BIRC5 11 -BIRC6 3142 -BIRC6-AS2 16 -BIRC7 8 -BIRC8 0 -BISPR 150 -BIVM 590 -BIVM-ERCC5 0 -BLACAT1 30 -BLACE 0 -BLCAP 4863 -BLID 14 -BLK 2 -BLM 300 -BLMH 645 -BLNK 195 -BLOC1S1 943 -BLOC1S1-RDH5 1 -BLOC1S2 1249 -BLOC1S3 361 -BLOC1S4 344 -BLOC1S5 0 -BLOC1S5-TXNDC5 5 -BLOC1S6 2270 -BLVRA 718 -BLVRB 672 -BLZF1 539 -BMF 234 -BMI1 176 -BMP1 1528 -BMP10 0 -BMP15 0 -BMP2 262 -BMP2K 840 -BMP3 40 -BMP4 1354 -BMP5 50 -BMP6 235 -BMP7 1835 -BMP7-AS1 2 -BMP8A 459 -BMP8B 129 -BMPER 81 -BMPR1A 490 -BMPR1B 1023 -BMPR1B-AS1 18 -BMPR2 5293 -BMS1 1495 -BMS1P17 0 -BMS1P18 0 -BMS1P20 242 -BMS1P21 42 -BMS1P4 143 -BMS1P5 97 -BMS1P6 29 -BMX 14 -BNC1 11 -BNC2 509 -BNIP1 335 -BNIP2 831 -BNIP3 1733 -BNIP3L 3145 -BNIPL 217 -BOC 1673 -BOD1 1506 -BOD1L1 4765 -BOD1L2 0 -BOK 2247 -BOK-AS1 9 -BOLA1 232 -BOLA2 0 -BOLA2B 0 -BOLA3 415 -BOLA3-AS1 556 -BOLL 7 -BOP1 1396 -BORA 71 -BPESC1 0 -BPGM 678 -BPHL 465 -BPI 4 -BPIFA1 2 -BPIFA2 0 -BPIFA3 0 -BPIFA4P 0 -BPIFB1 1 -BPIFB2 0 -BPIFB3 0 -BPIFB4 6 -BPIFB6 0 -BPIFC 4 -BPNT1 441 -BPTF 6431 -BPY2 0 -BPY2B 0 -BPY2C 0 -BRAF 362 -BRAP 1081 -BRAT1 1773 -BRCA1 353 -BRCA2 23 -BRCAT107 2 -BRCAT54 86 -BRCC3 445 -BRD1 2267 -BRD2 31 -BRD3 2165 -BRD4 6777 -BRD7 1626 -BRD7P3 9 -BRD8 2276 -BRD9 1043 -BRDT 0 -BRDTP1 0 -BRE 780 -BRE-AS1 2282 -BREA2 0 -BRF1 2658 -BRF2 289 -BRI3 2386 -BRI3BP 85 -BRICD5 433 -BRINP1 1442 -BRINP2 447 -BRINP3 577 -BRIP1 2 -BRIX1 658 -BRK1 3167 -BRMS1 651 -BRMS1L 586 -BROX 1507 -BRPF1 931 -BRPF3 2916 -BRS3 19 -BRSK1 6697 -BRSK2 3092 -BRWD1 3398 -BRWD1-AS1 2 -BRWD1-IT2 27 -BRWD3 1067 -BSCL2 290 -BSDC1 4278 -BSG 14157 -BSN 2939 -BSN-AS2 51 -BSND 1 -BSPH1 0 -BSPRY 77 -BST1 40 -BST2 2594 -BSX 55 -BTAF1 1207 -BTBD1 2509 -BTBD10 1171 -BTBD11 614 -BTBD16 9 -BTBD17 137 -BTBD18 96 -BTBD19 236 -BTBD2 6089 -BTBD3 2159 -BTBD6 2315 -BTBD7 1 -BTBD8 96 -BTBD9 1716 -BTC 26 -BTD 443 -BTF3 3916 -BTF3L4 924 -BTF3P11 0 -BTG1 3885 -BTG2 1676 -BTG3 2574 -BTG4 1 -BTK 164 -BTLA 11 -BTN1A1 19 -BTN2A1 1203 -BTN2A2 843 -BTN2A3P 259 -BTN3A1 473 -BTN3A2 648 -BTN3A3 645 -BTNL10 0 -BTNL2 1 -BTNL3 15 -BTNL8 5 -BTNL9 1073 -BTRC 2381 -BUB1 4 -BUB1B 12 -BUB3 2129 -BUD13 423 -BUD31 780 -BVES 1067 -BVES-AS1 51 -BYSL 372 -BZRAP1 3466 -BZRAP1-AS1 53 -BZW1 1097 -BZW2 188 -C10orf10 1637 -C10orf105 1535 -C10orf107 187 -C10orf11 137 -C10orf111 95 -C10orf113 4 -C10orf12 179 -C10orf120 0 -C10orf126 6 -C10orf128 283 -C10orf131 3 -C10orf142 28 -C10orf2 412 -C10orf25 146 -C10orf32 1166 -C10orf32-ASMT 0 -C10orf35 593 -C10orf53 4 -C10orf54 4421 -C10orf55 1 -C10orf62 8 -C10orf67 22 -C10orf71 0 -C10orf71-AS1 0 -C10orf76 1163 -C10orf82 43 -C10orf88 342 -C10orf90 161 -C10orf91 0 -C10orf95 56 -C10orf99 0 -C11orf1 403 -C11orf16 60 -C11orf21 14 -C11orf24 465 -C11orf30 1073 -C11orf31 1516 -C11orf39 18 -C11orf40 0 -C11orf42 19 -C11orf44 1 -C11orf45 99 -C11orf49 2860 -C11orf52 0 -C11orf53 2 -C11orf54 604 -C11orf57 1792 -C11orf58 3281 -C11orf63 734 -C11orf65 16 -C11orf68 1347 -C11orf70 299 -C11orf71 521 -C11orf72 1 -C11orf73 713 -C11orf74 414 -C11orf80 438 -C11orf84 4499 -C11orf85 1 -C11orf86 27 -C11orf87 218 -C11orf88 105 -C11orf91 24 -C11orf94 11 -C11orf95 1876 -C11orf96 3998 -C11orf97 35 -C11orf98 35 -C12orf10 1463 -C12orf29 713 -C12orf4 579 -C12orf40 0 -C12orf42 2 -C12orf43 644 -C12orf45 140 -C12orf49 2511 -C12orf50 2 -C12orf54 18 -C12orf56 13 -C12orf57 2748 -C12orf60 42 -C12orf65 1073 -C12orf66 231 -C12orf71 2 -C12orf73 250 -C12orf74 0 -C12orf75 376 -C12orf76 1030 -C12orf77 0 -C12orf79 17 -C12orf80 0 -C14orf1 1361 -C14orf105 5 -C14orf119 1218 -C14orf132 7031 -C14orf142 0 -C14orf159 2003 -C14orf166 1541 -C14orf169 433 -C14orf177 0 -C14orf178 17 -C14orf180 0 -C14orf2 1897 -C14orf28 147 -C14orf37 273 -C14orf39 85 -C14orf79 451 -C14orf80 226 -C14orf93 291 -C15orf26 93 -C15orf27 135 -C15orf32 1 -C15orf38-AP3S2 6 -C15orf39 699 -C15orf40 321 -C15orf41 175 -C15orf43 0 -C15orf48 5 -C15orf52 1426 -C15orf53 0 -C15orf54 7 -C15orf56 19 -C15orf57 492 -C15orf59 1505 -C15orf59-AS1 13 -C15orf61 305 -C15orf62 254 -C15orf65 130 -C16orf13 1355 -C16orf45 48 -C16orf46 389 -C16orf47 17 -C16orf52 1409 -C16orf54 16 -C16orf58 1903 -C16orf59 61 -C16orf62 2159 -C16orf70 579 -C16orf71 178 -C16orf72 2653 -C16orf74 22 -C16orf78 0 -C16orf82 18 -C16orf86 151 -C16orf87 202 -C16orf89 635 -C16orf90 6 -C16orf91 201 -C16orf92 0 -C16orf93 38 -C16orf95 75 -C16orf96 44 -C16orf97 0 -C17orf100 240 -C17orf102 15 -C17orf104 60 -C17orf105 0 -C17orf107 344 -C17orf112 0 -C17orf47 18 -C17orf49 21 -C17orf50 16 -C17orf51 1748 -C17orf53 69 -C17orf58 126 -C17orf59 333 -C17orf62 1669 -C17orf64 2 -C17orf67 530 -C17orf74 2 -C17orf75 782 -C17orf77 0 -C17orf78 0 -C17orf80 1182 -C17orf82 6 -C17orf85 1838 -C17orf89 810 -C17orf96 0 -C17orf97 477 -C17orf98 0 -C17orf99 0 -C18orf21 300 -C18orf25 1530 -C18orf32 133 -C18orf42 8 -C18orf54 109 -C18orf61 2 -C18orf63 0 -C18orf65 16 -C18orf8 782 -C19orf12 1466 -C19orf18 220 -C19orf24 970 -C19orf25 1319 -C19orf33 0 -C19orf35 103 -C19orf38 117 -C19orf43 5739 -C19orf44 586 -C19orf45 11 -C19orf47 583 -C19orf48 172 -C19orf52 417 -C19orf53 2279 -C19orf54 318 -C19orf57 135 -C19orf60 861 -C19orf66 1996 -C19orf67 0 -C19orf68 2361 -C19orf70 1470 -C19orf71 121 -C19orf73 60 -C19orf80 12 -C19orf81 68 -C19orf84 54 -C1D 128 -C1GALT1 845 -C1GALT1C1 629 -C1GALT1C1L 14 -C1QA 3323 -C1QB 4670 -C1QBP 1275 -C1QC 4146 -C1QL1 1459 -C1QL2 578 -C1QL3 54 -C1QL4 58 -C1QTNF1 956 -C1QTNF1-AS1 2 -C1QTNF2 75 -C1QTNF3 291 -C1QTNF3-AMACR 3 -C1QTNF4 681 -C1QTNF5 0 -C1QTNF6 228 -C1QTNF7 95 -C1QTNF8 90 -C1QTNF9 4 -C1QTNF9B 4 -C1QTNF9B-AS1 7 -C1R 9725 -C1RL 913 -C1RL-AS1 137 -C1S 6972 -C1orf100 2 -C1orf101 92 -C1orf105 2 -C1orf106 37 -C1orf109 412 -C1orf110 16 -C1orf111 50 -C1orf112 118 -C1orf115 747 -C1orf116 12 -C1orf122 2261 -C1orf123 1076 -C1orf127 2 -C1orf131 234 -C1orf137 0 -C1orf140 4 -C1orf141 26 -C1orf145 39 -C1orf146 0 -C1orf158 118 -C1orf159 312 -C1orf162 313 -C1orf167 1 -C1orf168 9 -C1orf174 399 -C1orf177 11 -C1orf185 0 -C1orf186 0 -C1orf189 6 -C1orf194 329 -C1orf195 2 -C1orf198 4323 -C1orf204 148 -C1orf21 3486 -C1orf210 0 -C1orf216 1976 -C1orf220 55 -C1orf226 1020 -C1orf228 254 -C1orf229 41 -C1orf233 1141 -C1orf234 3 -C1orf27 979 -C1orf35 961 -C1orf43 5703 -C1orf50 322 -C1orf52 1085 -C1orf53 38 -C1orf54 299 -C1orf56 321 -C1orf61 4012 -C1orf64 213 -C1orf68 0 -C1orf74 90 -C1orf87 155 -C1orf94 14 -C1orf95 1487 -C2 5 -C2-AS1 0 -C20orf141 0 -C20orf144 3 -C20orf166-AS1 14 -C20orf173 13 -C20orf194 3434 -C20orf195 61 -C20orf196 155 -C20orf197 5 -C20orf202 16 -C20orf203 89 -C20orf24 330 -C20orf27 1454 -C20orf62 0 -C20orf78 0 -C20orf85 15 -C20orf96 975 -C21orf140 0 -C21orf2 1257 -C21orf33 309 -C21orf58 240 -C21orf59 1272 -C21orf62 0 -C21orf62-AS1 3 -C21orf91 779 -C21orf91-OT1 2 -C22orf15 18 -C22orf23 485 -C22orf24 8 -C22orf29 756 -C22orf31 14 -C22orf34 47 -C22orf39 1207 -C22orf42 135 -C22orf46 4420 -C2CD2 2428 -C2CD2L 2064 -C2CD3 1527 -C2CD4A 155 -C2CD4B 350 -C2CD4C 1708 -C2CD4D 34 -C2CD5 1441 -C2orf15 89 -C2orf16 30 -C2orf27A 6 -C2orf27B 0 -C2orf40 1094 -C2orf42 833 -C2orf44 438 -C2orf47 223 -C2orf48 2 -C2orf49 866 -C2orf50 83 -C2orf54 3 -C2orf57 2 -C2orf61 34 -C2orf66 404 -C2orf68 621 -C2orf69 959 -C2orf70 95 -C2orf71 49 -C2orf72 1249 -C2orf73 49 -C2orf74 1373 -C2orf76 152 -C2orf78 2 -C2orf80 274 -C2orf81 387 -C2orf82 589 -C2orf83 8 -C2orf88 1115 -C2orf91 7 -C3 14430 -C3AR1 363 -C3P1 0 -C3orf14 1130 -C3orf17 1017 -C3orf18 811 -C3orf20 14 -C3orf22 1 -C3orf30 0 -C3orf33 300 -C3orf35 33 -C3orf36 26 -C3orf38 958 -C3orf49 34 -C3orf52 28 -C3orf56 0 -C3orf58 878 -C3orf62 584 -C3orf67 42 -C3orf67-AS1 5 -C3orf70 1072 -C3orf79 0 -C3orf80 59 -C3orf84 1 -C4A 0 -C4B 0 -C4BPA 7 -C4BPB 2 -C4B_2 0 -C4orf17 0 -C4orf19 215 -C4orf22 18 -C4orf26 10 -C4orf27 393 -C4orf29 192 -C4orf3 4062 -C4orf32 256 -C4orf33 274 -C4orf36 18 -C4orf45 0 -C4orf46 116 -C4orf47 228 -C4orf48 1283 -C4orf51 3 -C5 272 -C5AR1 419 -C5AR2 3 -C5orf15 830 -C5orf17 4 -C5orf22 630 -C5orf24 1721 -C5orf28 335 -C5orf30 632 -C5orf34 43 -C5orf38 366 -C5orf42 1277 -C5orf45 261 -C5orf46 0 -C5orf47 0 -C5orf49 937 -C5orf51 1948 -C5orf52 0 -C5orf56 335 -C5orf58 10 -C5orf60 5 -C5orf63 376 -C5orf64 28 -C5orf66 88 -C5orf66-AS1 1 -C5orf66-AS2 3 -C5orf67 0 -C6 96 -C6orf1 2097 -C6orf10 0 -C6orf106 4485 -C6orf118 132 -C6orf120 608 -C6orf132 13 -C6orf136 0 -C6orf141 40 -C6orf15 0 -C6orf163 49 -C6orf165 213 -C6orf201 27 -C6orf203 586 -C6orf222 3 -C6orf223 10 -C6orf226 164 -C6orf229 7 -C6orf25 0 -C6orf47 0 -C6orf48 1 -C6orf52 52 -C6orf58 1 -C6orf62 5915 -C6orf7 2 -C6orf89 4962 -C6orf99 19 -C7 1033 -C7orf13 318 -C7orf25 668 -C7orf26 986 -C7orf31 263 -C7orf33 0 -C7orf34 0 -C7orf43 1117 -C7orf49 427 -C7orf50 1444 -C7orf55 211 -C7orf55-LUC7L2 0 -C7orf57 148 -C7orf60 1550 -C7orf61 802 -C7orf62 4 -C7orf65 0 -C7orf66 1 -C7orf69 2 -C7orf71 4 -C7orf72 0 -C7orf73 886 -C7orf76 1 -C7orf77 0 -C8A 0 -C8B 0 -C8G 14 -C8orf22 28 -C8orf31 14 -C8orf33 1279 -C8orf34 327 -C8orf34-AS1 87 -C8orf37 396 -C8orf37-AS1 4 -C8orf4 266 -C8orf44 126 -C8orf44-SGK3 0 -C8orf46 1069 -C8orf48 15 -C8orf49 0 -C8orf58 245 -C8orf59 549 -C8orf74 0 -C8orf76 165 -C8orf82 618 -C8orf86 5 -C8orf87 0 -C8orf88 76 -C8orf89 4 -C9 3 -C9orf106 0 -C9orf114 2276 -C9orf116 335 -C9orf117 860 -C9orf129 70 -C9orf131 76 -C9orf135 62 -C9orf135-AS1 2 -C9orf139 34 -C9orf142 1354 -C9orf152 22 -C9orf153 24 -C9orf156 375 -C9orf16 1874 -C9orf163 17 -C9orf170 11 -C9orf171 145 -C9orf172 2461 -C9orf173 3 -C9orf173-AS1 4 -C9orf24 389 -C9orf3 755 -C9orf40 508 -C9orf41-AS1 5 -C9orf43 62 -C9orf47 100 -C9orf50 34 -C9orf57 1 -C9orf62 0 -C9orf64 410 -C9orf66 11 -C9orf69 895 -C9orf72 1283 -C9orf78 3090 -C9orf84 188 -C9orf85 96 -C9orf89 483 -C9orf9 382 -C9orf91 818 -C9orf92 1 -CA1 2 -CA10 1101 -CA11 2511 -CA12 4775 -CA13 361 -CA14 79 -CA2 1608 -CA3 142 -CA3-AS1 48 -CA4 79 -CA5A 12 -CA5B 409 -CA5BP1 434 -CA6 0 -CA7 42 -CA8 311 -CA9 6 -CAAP1 480 -CAB39 3493 -CAB39L 3739 -CABIN1 5403 -CABLES1 1235 -CABLES2 612 -CABP1 503 -CABP2 0 -CABP4 63 -CABP5 2 -CABP7 133 -CABS1 2 -CABYR 422 -CACFD1 1321 -CACHD1 3191 -CACNA1A 4345 -CACNA1B 1911 -CACNA1C 1300 -CACNA1C-AS1 32 -CACNA1C-AS2 23 -CACNA1C-AS4 1 -CACNA1C-IT2 1 -CACNA1C-IT3 5 -CACNA1D 523 -CACNA1E 1417 -CACNA1F 19 -CACNA1G 797 -CACNA1G-AS1 18 -CACNA1H 2126 -CACNA1I 861 -CACNA1S 18 -CACNA2D1 2340 -CACNA2D2 2681 -CACNA2D3 657 -CACNA2D3-AS1 3 -CACNA2D4 26 -CACNB1 2282 -CACNB2 1229 -CACNB3 1899 -CACNB4 578 -CACNG1 1 -CACNG2 931 -CACNG3 194 -CACNG4 1743 -CACNG5 7 -CACNG6 13 -CACNG7 2615 -CACNG8 4087 -CACTIN 1114 -CACTIN-AS1 45 -CACUL1 1873 -CACYBP 9211 -CAD 1375 -CADM1 6296 -CADM2 1620 -CADM2-AS2 1 -CADM3 8312 -CADM3-AS1 84 -CADM4 5888 -CADPS 2231 -CADPS2 1372 -CAGE1 2 -CAHM 113 -CALB1 2110 -CALB2 5214 -CALCA 130 -CALCB 156 -CALCOCO1 4661 -CALCOCO2 4128 -CALCR 481 -CALCRL 1696 -CALD1 8659 -CALHM1 15 -CALHM2 487 -CALHM3 5 -CALM1 30610 -CALM2 19458 -CALM3 23538 -CALML3 11 -CALML3-AS1 16 -CALML4 831 -CALML5 0 -CALML6 9 -CALN1 1788 -CALR 25796 -CALR3 0 -CALU 3228 -CALY 18857 -CAMK1 1503 -CAMK1D 3392 -CAMK1G 872 -CAMK2A 5075 -CAMK2B 9739 -CAMK2D 2834 -CAMK2G 5436 -CAMK2N1 8209 -CAMK2N2 3148 -CAMK4 128 -CAMKK1 939 -CAMKK2 1112 -CAMKMT 345 -CAMKV 2447 -CAMLG 1607 -CAMP 4 -CAMSAP1 2326 -CAMSAP2 4614 -CAMSAP3 1328 -CAMTA1 5068 -CAMTA2 4077 -CAND1 3010 -CAND1.11 3 -CAND2 1004 -CANT1 1258 -CANX 25603 -CAP1 4827 -CAP2 2371 -CAPG 949 -CAPN1 3133 -CAPN10 872 -CAPN10-AS1 165 -CAPN11 2 -CAPN12 141 -CAPN13 8 -CAPN14 3 -CAPN15 2103 -CAPN2 5424 -CAPN3 1032 -CAPN5 1033 -CAPN6 17 -CAPN7 1595 -CAPN8 13 -CAPN9 21 -CAPNS1 9663 -CAPNS2 1 -CAPRIN1 6335 -CAPRIN2 2073 -CAPS 6035 -CAPS2 378 -CAPSL 150 -CAPZA1 2409 -CAPZA2 1994 -CAPZA3 1 -CAPZB 4930 -CARD10 190 -CARD11 406 -CARD14 236 -CARD16 133 -CARD17 0 -CARD18 0 -CARD6 603 -CARD8 1176 -CARD8-AS1 68 -CARD9 287 -CARF 385 -CARHSP1 2010 -CARKD 1998 -CARM1 2778 -CARNMT1 114 -CARNS1 526 -CARS 873 -CARS2 1617 -CARTPT 4500 -CASC1 180 -CASC10 429 -CASC11 0 -CASC15 94 -CASC16 0 -CASC17 2 -CASC18 5 -CASC19 0 -CASC2 593 -CASC20 0 -CASC21 2 -CASC23 0 -CASC3 10873 -CASC4 5431 -CASC5 6 -CASC6 0 -CASC8 2 -CASC9 3 -CASD1 1996 -CASK 1987 -CASKIN1 5504 -CASKIN2 2375 -CASP1 1111 -CASP10 602 -CASP12 38 -CASP14 0 -CASP16P 4 -CASP1P2 0 -CASP2 760 -CASP3 511 -CASP4 702 -CASP5 36 -CASP6 250 -CASP7 1362 -CASP8 200 -CASP8AP2 1029 -CASP9 922 -CASQ1 118 -CASQ2 109 -CASR 9 -CASS4 187 -CAST 4510 -CASZ1 480 -CAT 2220 -CATIP 60 -CATIP-AS1 9 -CATIP-AS2 9 -CATSPER1 0 -CATSPER2 131 -CATSPER2P1 33 -CATSPER3 46 -CATSPER4 0 -CATSPERB 0 -CATSPERD 15 -CATSPERG 80 -CAV1 709 -CAV2 449 -CAV3 13 -CBARP 1637 -CBFA2T2 2371 -CBFA2T3 484 -CBFB 1741 -CBL 2978 -CBLB 733 -CBLC 4 -CBLL1 857 -CBLN1 1491 -CBLN2 161 -CBLN3 255 -CBLN4 666 -CBR1 2338 -CBR3 150 -CBR3-AS1 72 -CBR4 866 -CBS 52 -CBWD1 206 -CBWD2 206 -CBWD3 1 -CBWD5 87 -CBWD6 54 -CBX1 2711 -CBX2 43 -CBX3 3142 -CBX3P2 4 -CBX4 1640 -CBX5 10013 -CBX6 8340 -CBX7 4793 -CBX8 101 -CBY1 998 -CBY3 18 -CC2D1A 3865 -CC2D1B 2266 -CC2D2A 888 -CC2D2B 13 -CCAR1 3942 -CCAR2 3151 -CCAT1 0 -CCAT2 0 -CCBE1 52 -CCBL1 650 -CCBL2 429 -CCDC101 488 -CCDC102A 928 -CCDC102B 71 -CCDC103 431 -CCDC105 4 -CCDC106 1368 -CCDC107 168 -CCDC108 380 -CCDC109B 358 -CCDC110 178 -CCDC112 737 -CCDC113 607 -CCDC114 951 -CCDC115 748 -CCDC116 21 -CCDC117 2760 -CCDC12 957 -CCDC120 1186 -CCDC121 316 -CCDC122 78 -CCDC124 2686 -CCDC125 8 -CCDC126 294 -CCDC127 559 -CCDC129 72 -CCDC13 230 -CCDC13-AS1 4 -CCDC130 1544 -CCDC134 55 -CCDC136 1803 -CCDC137 985 -CCDC138 120 -CCDC14 1616 -CCDC140 2 -CCDC141 21 -CCDC142 654 -CCDC144A 37 -CCDC144B 142 -CCDC144CP 116 -CCDC144NL 41 -CCDC144NL-AS1 9 -CCDC146 931 -CCDC148 276 -CCDC148-AS1 2 -CCDC149 1381 -CCDC15 54 -CCDC150 5 -CCDC151 1185 -CCDC152 505 -CCDC153 98 -CCDC154 291 -CCDC155 1 -CCDC157 147 -CCDC158 110 -CCDC159 579 -CCDC160 152 -CCDC162P 11 -CCDC163P 282 -CCDC166 0 -CCDC167 308 -CCDC168 34 -CCDC169 3 -CCDC169-SOHLH2 0 -CCDC17 59 -CCDC170 450 -CCDC171 72 -CCDC172 0 -CCDC173 1503 -CCDC174 1056 -CCDC175 122 -CCDC176 609 -CCDC177 92 -CCDC178 19 -CCDC179 0 -CCDC18 336 -CCDC180 1 -CCDC181 1600 -CCDC182 0 -CCDC183 145 -CCDC183-AS1 111 -CCDC184 1668 -CCDC185 2 -CCDC186 1221 -CCDC22 532 -CCDC24 653 -CCDC25 2025 -CCDC26 1 -CCDC27 0 -CCDC28A 1095 -CCDC28B 233 -CCDC3 693 -CCDC30 584 -CCDC33 59 -CCDC34 1109 -CCDC36 108 -CCDC37 583 -CCDC37-AS1 1 -CCDC38 6 -CCDC39 391 -CCDC40 1858 -CCDC42 1 -CCDC42B 230 -CCDC43 562 -CCDC47 2985 -CCDC50 2584 -CCDC51 267 -CCDC53 1058 -CCDC54 5 -CCDC57 665 -CCDC58 121 -CCDC59 1086 -CCDC6 2956 -CCDC60 51 -CCDC61 364 -CCDC62 184 -CCDC63 0 -CCDC64 1622 -CCDC64B 6 -CCDC65 427 -CCDC66 918 -CCDC67 70 -CCDC68 129 -CCDC69 1372 -CCDC7 387 -CCDC70 1 -CCDC71 306 -CCDC71L 1522 -CCDC73 42 -CCDC74A 506 -CCDC74B 395 -CCDC77 190 -CCDC78 274 -CCDC79 1 -CCDC8 681 -CCDC80 1769 -CCDC81 203 -CCDC82 1257 -CCDC83 0 -CCDC84 700 -CCDC85A 1397 -CCDC85B 1899 -CCDC85C 1489 -CCDC86 658 -CCDC87 8 -CCDC88A 9943 -CCDC88B 1175 -CCDC88C 510 -CCDC89 52 -CCDC9 985 -CCDC90B 1468 -CCDC91 2630 -CCDC92 145 -CCDC93 2121 -CCDC94 582 -CCDC96 321 -CCDC97 1182 -CCER1 0 -CCER2 59 -CCHCR1 13 -CCHE1 1109 -CCIN 8 -CCK 441 -CCKAR 16 -CCKBR 34 -CCL1 0 -CCL11 6 -CCL13 0 -CCL14 0 -CCL15 0 -CCL15-CCL14 0 -CCL16 1 -CCL17 6 -CCL18 0 -CCL19 70 -CCL2 732 -CCL20 3 -CCL21 8 -CCL22 2 -CCL23 0 -CCL24 0 -CCL25 3 -CCL26 46 -CCL27 19 -CCL28 114 -CCL3 0 -CCL3L1 0 -CCL3L3 0 -CCL4 0 -CCL4L1 0 -CCL4L2 0 -CCL5 0 -CCL7 0 -CCL8 7 -CCM2 2624 -CCM2L 215 -CCNA1 341 -CCNA2 566 -CCNB1 146 -CCNB1IP1 963 -CCNB2 6 -CCNB3 21 -CCNC 842 -CCND1 3681 -CCND2 5113 -CCND2-AS1 69 -CCND3 3161 -CCNDBP1 1508 -CCNE1 79 -CCNE2 70 -CCNF 392 -CCNG1 1736 -CCNG2 572 -CCNH 396 -CCNI 6730 -CCNI2 216 -CCNJ 183 -CCNJL 133 -CCNK 2137 -CCNL1 2309 -CCNL2 4851 -CCNO 281 -CCNT1 1207 -CCNT2 1904 -CCNT2-AS1 55 -CCNY 2431 -CCNYL1 523 -CCNYL2 32 -CCP110 2241 -CCPG1 1117 -CCR1 135 -CCR10 190 -CCR2 24 -CCR3 0 -CCR4 0 -CCR5 51 -CCR6 14 -CCR7 5 -CCR8 1 -CCR9 5 -CCRL2 23 -CCS 800 -CCSAP 1388 -CCSER1 97 -CCSER2 3292 -CCT2 4047 -CCT3 8794 -CCT4 6375 -CCT5 6170 -CCT6A 6765 -CCT6B 16 -CCT6P1 228 -CCT6P3 94 -CCT7 5407 -CCT8 3575 -CCT8L2 1 -CCZ1 133 -CCZ1B 290 -CD101 15 -CD109 423 -CD14 805 -CD151 4241 -CD160 131 -CD163 1759 -CD163L1 46 -CD164 6066 -CD164L2 6 -CD177 25 -CD180 153 -CD19 7 -CD1A 1 -CD1B 0 -CD1C 0 -CD1D 11 -CD1E 1 -CD2 55 -CD200 3300 -CD200R1 27 -CD200R1L 0 -CD207 2 -CD209 29 -CD22 715 -CD226 24 -CD24 895 -CD244 7 -CD247 76 -CD248 95 -CD27 33 -CD27-AS1 836 -CD274 449 -CD276 752 -CD28 6 -CD2AP 841 -CD2BP2 3466 -CD300A 210 -CD300C 37 -CD300E 5 -CD300LB 9 -CD300LD 0 -CD300LF 64 -CD300LG 2 -CD302 2 -CD320 1490 -CD33 58 -CD34 734 -CD36 166 -CD37 686 -CD38 45 -CD3D 7 -CD3E 65 -CD3EAP 118 -CD3G 4 -CD4 819 -CD40 434 -CD40LG 12 -CD44 5638 -CD46 2344 -CD47 3026 -CD48 76 -CD5 48 -CD52 30 -CD53 733 -CD55 1443 -CD58 257 -CD59 18661 -CD5L 1 -CD6 108 -CD63 11784 -CD68 1452 -CD69 28 -CD7 75 -CD70 1 -CD72 65 -CD74 26096 -CD79A 54 -CD79B 10 -CD80 6 -CD81 19100 -CD81-AS1 29 -CD82 678 -CD83 918 -CD84 329 -CD86 298 -CD8A 189 -CD8B 25 -CD9 1578 -CD93 1069 -CD96 30 -CD99 12 -CD99L2 5772 -CD99P1 23 -CDA 189 -CDADC1 540 -CDAN1 749 -CDC123 1023 -CDC14A 808 -CDC14B 1286 -CDC14C 2 -CDC16 2230 -CDC20 11 -CDC20B 5 -CDC23 533 -CDC25A 99 -CDC25B 2777 -CDC25C 9 -CDC26 101 -CDC27 1835 -CDC34 2083 -CDC37 6853 -CDC37L1 1143 -CDC37L1-AS1 30 -CDC40 524 -CDC42 2762 -CDC42BPA 5310 -CDC42BPB 8664 -CDC42BPG 49 -CDC42EP1 2447 -CDC42EP2 275 -CDC42EP3 1313 -CDC42EP4 8599 -CDC42EP5 1 -CDC42P3 29 -CDC42SE1 3856 -CDC42SE2 2131 -CDC45 24 -CDC5L 1656 -CDC6 93 -CDC7 335 -CDC73 1536 -CDCA2 15 -CDCA3 54 -CDCA4 92 -CDCA5 38 -CDCA7 40 -CDCA7L 92 -CDCA8 24 -CDCP1 99 -CDCP2 2 -CDH1 69 -CDH10 809 -CDH11 1983 -CDH12 112 -CDH13 660 -CDH15 1 -CDH16 1 -CDH17 4 -CDH18 755 -CDH19 232 -CDH2 4270 -CDH20 993 -CDH22 560 -CDH23 835 -CDH24 701 -CDH26 106 -CDH3 122 -CDH4 223 -CDH5 939 -CDH6 821 -CDH7 84 -CDH8 245 -CDH9 51 -CDHR1 727 -CDHR2 118 -CDHR3 383 -CDHR4 43 -CDHR5 0 -CDIP1 30 -CDIPT 2747 -CDIPT-AS1 18 -CDK1 16 -CDK10 1921 -CDK11A 4032 -CDK11B 2698 -CDK12 1752 -CDK13 2543 -CDK14 1494 -CDK15 12 -CDK16 2963 -CDK17 1905 -CDK18 3953 -CDK19 1202 -CDK2 277 -CDK20 638 -CDK2AP1 8382 -CDK2AP2 4439 -CDK3 0 -CDK4 1272 -CDK5 750 -CDK5R1 2845 -CDK5R2 2271 -CDK5RAP1 530 -CDK5RAP2 1919 -CDK5RAP3 4840 -CDK6 669 -CDK7 0 -CDK8 363 -CDK9 4213 -CDKAL1 294 -CDKL1 254 -CDKL2 653 -CDKL3 344 -CDKL4 14 -CDKL5 240 -CDKN1A 4526 -CDKN1B 3908 -CDKN1C 21 -CDKN2A 127 -CDKN2A-AS1 0 -CDKN2AIP 927 -CDKN2AIPNL 485 -CDKN2B 480 -CDKN2B-AS1 24 -CDKN2C 752 -CDKN2D 1435 -CDKN3 39 -CDNF 29 -CDO1 1282 -CDON 517 -CDPF1 135 -CDR1 1370 -CDR2 1323 -CDR2L 960 -CDRT1 32 -CDRT15 0 -CDRT15L2 1 -CDRT15P1 6 -CDRT15P2 1 -CDRT4 3 -CDRT7 0 -CDRT8 0 -CDS1 1036 -CDS2 8094 -CDSN 0 -CDT1 76 -CDV3 4049 -CDX1 3 -CDX2 0 -CDX4 0 -CDY1 0 -CDY1B 0 -CDY2A 0 -CDY2B 0 -CDYL 986 -CDYL2 214 -CEACAM1 84 -CEACAM16 5 -CEACAM18 0 -CEACAM19 702 -CEACAM20 0 -CEACAM21 9 -CEACAM22P 0 -CEACAM3 5 -CEACAM4 0 -CEACAM5 0 -CEACAM6 11 -CEACAM7 0 -CEACAM8 1 -CEBPA 960 -CEBPA-AS1 75 -CEBPB 4197 -CEBPB-AS1 175 -CEBPD 11873 -CEBPE 1 -CEBPG 4190 -CEBPZ 1767 -CEBPZOS 1977 -CECR1 2006 -CECR2 1374 -CECR3 1 -CECR5 502 -CECR5-AS1 16 -CECR6 265 -CECR7 200 -CEL 269 -CELA1 0 -CELA2A 1 -CELA2B 7 -CELA3A 0 -CELA3B 1 -CELF1 6068 -CELF2 4550 -CELF2-AS1 49 -CELF2-AS2 4 -CELF3 4589 -CELF4 10147 -CELF5 8319 -CELF6 2452 -CELP 37 -CELSR1 988 -CELSR2 6143 -CELSR3 2007 -CELSR3-AS1 6 -CEMIP 1786 -CEMP1 188 -CEND1 3449 -CENPA 5 -CENPB 6500 -CENPBD1 595 -CENPBD1P1 1291 -CENPC 364 -CENPE 62 -CENPF 56 -CENPH 43 -CENPI 7 -CENPJ 387 -CENPK 7 -CENPL 156 -CENPM 9 -CENPN 282 -CENPO 434 -CENPP 53 -CENPQ 161 -CENPT 1784 -CENPU 31 -CENPV 527 -CENPVP1 0 -CENPVP2 0 -CENPW 24 -CEP104 1909 -CEP112 1156 -CEP120 1158 -CEP126 2999 -CEP128 92 -CEP131 562 -CEP135 374 -CEP152 205 -CEP162 617 -CEP164 1835 -CEP170 0 -CEP170B 4888 -CEP170P1 57 -CEP19 901 -CEP192 1039 -CEP250 2267 -CEP290 2143 -CEP295 896 -CEP295NL 130 -CEP350 3003 -CEP41 1299 -CEP44 472 -CEP55 7 -CEP57 997 -CEP57L1 210 -CEP63 1544 -CEP68 946 -CEP70 783 -CEP72 36 -CEP76 273 -CEP78 239 -CEP83 390 -CEP83-AS1 20 -CEP85 499 -CEP85L 928 -CEP89 546 -CEP95 1215 -CEP97 997 -CEPT1 1096 -CER1 3 -CERCAM 1953 -CERK 2338 -CERKL 76 -CERS1 3514 -CERS2 5327 -CERS3 6 -CERS3-AS1 1 -CERS4 1954 -CERS5 1747 -CERS6 1661 -CERS6-AS1 0 -CES1 1 -CES1P1 16 -CES1P2 9 -CES2 1981 -CES3 118 -CES4A 1053 -CES5A 1 -CES5AP1 1 -CETN1 0 -CETN2 3070 -CETN3 886 -CETN4P 19 -CETP 33 -CFAP126 490 -CFAP20 1197 -CFAP221 461 -CFAP36 2911 -CFAP43 1220 -CFAP44 1899 -CFAP44-AS1 1 -CFAP45 353 -CFAP46 966 -CFAP47 170 -CFAP52 389 -CFAP53 765 -CFAP54 725 -CFAP57 267 -CFAP58 78 -CFAP58-AS1 101 -CFAP61 223 -CFAP69 422 -CFAP70 791 -CFAP74 257 -CFAP97 1111 -CFAP99 140 -CFB 38 -CFC1 61 -CFC1B 4 -CFD 0 -CFDP1 2800 -CFH 1291 -CFHR1 3 -CFHR2 0 -CFHR3 18 -CFHR4 1 -CFHR5 0 -CFI 816 -CFL1 13618 -CFL1P1 36 -CFL2 2142 -CFLAR 6867 -CFLAR-AS1 15 -CFP 124 -CFTR 9 -CGA 35 -CGB 0 -CGB1 0 -CGB2 0 -CGB5 1 -CGB7 1 -CGB8 0 -CGGBP1 3625 -CGN 537 -CGNL1 3053 -CGREF1 642 -CGRRF1 415 -CH17-340M24.3 128 -CH17-360D5.1 0 -CH17-408M7.1 12 -CH25H 651 -CHAC1 1996 -CHAC2 101 -CHAD 155 -CHADL 585 -CHAF1A 256 -CHAF1B 116 -CHAMP1 601 -CHAT 10 -CHCHD1 509 -CHCHD10 877 -CHCHD2 3268 -CHCHD3 682 -CHCHD4 566 -CHCHD5 266 -CHCHD6 435 -CHCHD7 593 -CHD1 1513 -CHD1L 910 -CHD2 8838 -CHD3 11441 -CHD4 8384 -CHD5 5476 -CHD6 5415 -CHD7 3352 -CHD8 2992 -CHD9 3938 -CHDH 1357 -CHEK1 161 -CHEK2 152 -CHEK2P2 6 -CHERP 2049 -CHFR 673 -CHGA 0 -CHGB 10050 -CHI3L1 9837 -CHI3L2 245 -CHIA 0 -CHIAP2 0 -CHIC1 1166 -CHIC2 461 -CHID1 1949 -CHIT1 3 -CHKA 2016 -CHKB 96 -CHKB-AS1 70 -CHKB-CPT1B 12 -CHL1 3562 -CHL1-AS1 4 -CHM 840 -CHML 198 -CHMP1A 2490 -CHMP1B 1900 -CHMP1B2P 111 -CHMP2A 2713 -CHMP2B 1119 -CHMP3 176 -CHMP4A 1425 -CHMP4B 4105 -CHMP4C 32 -CHMP5 1715 -CHMP6 285 -CHMP7 1739 -CHN1 4700 -CHN2 693 -CHODL 231 -CHODL-AS1 1 -CHORDC1 6303 -CHP1 2471 -CHP2 3 -CHPF 5001 -CHPF2 2283 -CHPT1 2205 -CHRAC1 540 -CHRD 371 -CHRDL1 539 -CHRDL2 31 -CHRFAM7A 7 -CHRM1 148 -CHRM2 12 -CHRM3 76 -CHRM3-AS1 1 -CHRM3-AS2 1 -CHRM4 138 -CHRM5 102 -CHRNA1 9 -CHRNA10 195 -CHRNA2 7 -CHRNA3 131 -CHRNA4 625 -CHRNA5 277 -CHRNA6 36 -CHRNA7 12 -CHRNA9 3 -CHRNB1 290 -CHRNB2 858 -CHRNB3 4 -CHRNB4 3 -CHRND 12 -CHRNE 36 -CHRNG 4 -CHST1 2260 -CHST10 1609 -CHST11 2499 -CHST12 935 -CHST13 8 -CHST14 417 -CHST15 1186 -CHST2 3102 -CHST3 2012 -CHST4 9 -CHST5 245 -CHST6 1880 -CHST7 471 -CHST8 546 -CHST9 182 -CHSY1 1418 -CHSY3 142 -CHTF18 300 -CHTF8 1430 -CHTOP 2246 -CHUK 910 -CHURC1 2051 -CHURC1-FNTB 0 -CIAO1 2949 -CIAPIN1 642 -CIART 802 -CIB1 1423 -CIB2 470 -CIB3 1 -CIB4 5 -CIC 6668 -CIDEA 0 -CIDEB 6 -CIDEC 0 -CIDECP 267 -CIITA 943 -CILP 61 -CILP2 130 -CINP 559 -CIPC 2691 -CIR1 2426 -CIRBP 3708 -CIRBP-AS1 123 -CIRH1A 151 -CISD1 962 -CISD2 764 -CISD3 0 -CISH 784 -CISTR 0 -CIT 4343 -CITED1 1787 -CITED2 1200 -CITED4 584 -CIZ1 5249 -CKAP2 522 -CKAP2L 5 -CKAP4 1419 -CKAP5 3732 -CKB 21827 -CKLF 147 -CKLF-CMTM1 0 -CKM 41 -CKMT1A 154 -CKMT1B 212 -CKMT2 97 -CKMT2-AS1 473 -CKS1B 91 -CKS2 128 -CLASP1 5581 -CLASP2 4778 -CLASRP 3425 -CLC 3 -CLCA1 0 -CLCA2 7 -CLCA3P 0 -CLCA4 99 -CLCC1 1239 -CLCF1 303 -CLCN1 4 -CLCN2 797 -CLCN3 4005 -CLCN4 1805 -CLCN5 803 -CLCN6 3552 -CLCN7 4307 -CLCNKA 22 -CLCNKB 19 -CLDN1 113 -CLDN10 465 -CLDN10-AS1 0 -CLDN11 1559 -CLDN12 2499 -CLDN14 3 -CLDN15 802 -CLDN16 3 -CLDN17 0 -CLDN18 32 -CLDN19 51 -CLDN2 13 -CLDN20 6 -CLDN22 0 -CLDN23 64 -CLDN24 5 -CLDN25 0 -CLDN3 68 -CLDN34 1 -CLDN4 24 -CLDN5 3373 -CLDN6 5 -CLDN7 36 -CLDN8 0 -CLDN9 122 -CLDND1 6029 -CLDND2 24 -CLEC10A 20 -CLEC11A 326 -CLEC12A 4 -CLEC12B 0 -CLEC14A 295 -CLEC16A 1927 -CLEC17A 20 -CLEC18A 11 -CLEC18B 64 -CLEC18C 6 -CLEC19A 15 -CLEC1A 212 -CLEC1B 1 -CLEC2A 1 -CLEC2B 569 -CLEC2D 343 -CLEC2L 164 -CLEC3A 0 -CLEC3B 709 -CLEC4A 67 -CLEC4C 0 -CLEC4D 1 -CLEC4E 79 -CLEC4F 8 -CLEC4G 29 -CLEC4GP1 102 -CLEC4M 0 -CLEC5A 422 -CLEC6A 1 -CLEC7A 120 -CLEC9A 52 -CLECL1 19 -CLGN 330 -CLHC1 562 -CLIC1 0 -CLIC2 1943 -CLIC3 62 -CLIC4 4393 -CLIC5 830 -CLIC6 294 -CLINT1 1686 -CLIP1 4697 -CLIP1-AS1 12 -CLIP2 13106 -CLIP3 15953 -CLIP4 1616 -CLK1 12921 -CLK2 0 -CLK2P1 87 -CLK3 1939 -CLK4 1391 -CLLU1 0 -CLLU1OS 0 -CLMN 1472 -CLMP 79 -CLN3 732 -CLN5 1005 -CLN6 422 -CLN8 4 -CLNK 1 -CLNS1A 1792 -CLOCK 2585 -CLP1 149 -CLPB 688 -CLPP 1184 -CLPS 1 -CLPSL1 0 -CLPSL2 2 -CLPTM1 7541 -CLPTM1L 909 -CLPX 509 -CLRN1 3 -CLRN1-AS1 0 -CLRN2 0 -CLRN3 2 -CLSPN 48 -CLSTN1 15330 -CLSTN2 508 -CLSTN2-AS1 1 -CLSTN3 9742 -CLTA 3470 -CLTB 4194 -CLTC 11752 -CLTCL1 458 -CLU 239204 -CLUAP1 1538 -CLUH 2603 -CLUHP3 153 -CLUL1 50 -CLVS1 343 -CLVS2 991 -CLYBL 235 -CLYBL-AS1 3 -CLYBL-AS2 0 -CMA1 0 -CMAHP 245 -CMAS 2272 -CMBL 911 -CMC1 311 -CMC2 771 -CMC4 314 -CMIP 10300 -CMKLR1 275 -CMPK1 4074 -CMPK2 240 -CMSS1 740 -CMTM1 107 -CMTM2 21 -CMTM3 940 -CMTM4 5002 -CMTM5 285 -CMTM6 1255 -CMTM7 195 -CMTM8 119 -CMTR1 1805 -CMTR2 834 -CMYA5 1695 -CNBD1 0 -CNBD2 11 -CNBP 7565 -CNDP1 931 -CNDP2 4332 -CNEP1R1 566 -CNFN 26 -CNGA1 13 -CNGA2 0 -CNGA3 165 -CNGA4 55 -CNGB1 1881 -CNGB3 1 -CNIH1 1027 -CNIH2 6283 -CNIH3 141 -CNIH4 775 -CNKSR1 312 -CNKSR2 1108 -CNKSR3 907 -CNN1 507 -CNN2 1119 -CNN3 10190 -CNNM1 2110 -CNNM2 998 -CNNM3 1420 -CNNM4 630 -CNOT1 3234 -CNOT10 582 -CNOT11 1045 -CNOT2 2752 -CNOT3 90 -CNOT4 2191 -CNOT6 1487 -CNOT6L 1381 -CNOT7 1725 -CNOT8 1906 -CNP 7931 -CNPPD1 1514 -CNPY1 8 -CNPY2 2270 -CNPY3 2376 -CNPY4 475 -CNR1 1150 -CNR2 0 -CNRIP1 1982 -CNST 1649 -CNTD1 67 -CNTD2 174 -CNTF 1 -CNTFR 4818 -CNTFR-AS1 13 -CNTLN 603 -CNTN1 4279 -CNTN2 5081 -CNTN3 339 -CNTN4 488 -CNTN4-AS1 5 -CNTN4-AS2 0 -CNTN5 88 -CNTN6 99 -CNTNAP1 5383 -CNTNAP2 146 -CNTNAP3 71 -CNTNAP3B 38 -CNTNAP3P2 91 -CNTNAP4 1076 -CNTNAP5 202 -CNTRL 872 -CNTROB 815 -COA1 851 -COA3 1175 -COA4 900 -COA5 1327 -COA6 479 -COA7 265 -COASY 1702 -COBL 3532 -COBLL1 713 -COCH 332 -COG1 1054 -COG2 624 -COG3 920 -COG4 1832 -COG5 1040 -COG6 734 -COG7 1460 -COG8 480 -COIL 539 -COL10A1 11 -COL11A1 1454 -COL11A2 1 -COL12A1 532 -COL13A1 116 -COL14A1 845 -COL15A1 184 -COL16A1 7272 -COL17A1 12 -COL18A1 7394 -COL18A1-AS1 49 -COL18A1-AS2 2 -COL19A1 28 -COL1A1 1042 -COL1A2 5793 -COL20A1 210 -COL21A1 1102 -COL22A1 1670 -COL23A1 161 -COL24A1 1422 -COL25A1 2889 -COL26A1 155 -COL27A1 3476 -COL28A1 268 -COL2A1 372 -COL3A1 563 -COL4A1 1844 -COL4A2 2601 -COL4A2-AS1 6 -COL4A3 284 -COL4A3BP 2164 -COL4A4 323 -COL4A5 2214 -COL4A6 589 -COL5A1 1673 -COL5A2 1018 -COL5A3 980 -COL6A1 12636 -COL6A2 5554 -COL6A3 270 -COL6A4P1 2 -COL6A4P2 128 -COL6A5 3 -COL6A6 24 -COL7A1 3598 -COL8A1 2731 -COL8A2 760 -COL9A1 552 -COL9A2 3052 -COL9A3 1194 -COLCA1 91 -COLCA2 223 -COLEC10 4 -COLEC11 24 -COLEC12 1507 -COLGALT1 2169 -COLGALT2 1251 -COLQ 418 -COMMD1 442 -COMMD10 411 -COMMD2 680 -COMMD3 416 -COMMD3-BMI1 0 -COMMD4 525 -COMMD5 480 -COMMD6 990 -COMMD7 1264 -COMMD8 277 -COMMD9 918 -COMP 3 -COMT 3924 -COMTD1 208 -COPA 8474 -COPB1 2506 -COPB2 3325 -COPE 3844 -COPG1 3928 -COPG2 2467 -COPG2IT1 7948 -COPRS 2463 -COPS2 2476 -COPS3 1206 -COPS4 1244 -COPS5 1405 -COPS6 2956 -COPS7A 2096 -COPS7B 1170 -COPS8 2239 -COPZ1 2425 -COPZ2 328 -COQ10A 459 -COQ10B 824 -COQ2 190 -COQ3 233 -COQ4 841 -COQ5 496 -COQ6 290 -COQ7 694 -COQ9 1239 -CORIN 309 -CORO1A 951 -CORO1B 1991 -CORO1C 3729 -CORO2A 409 -CORO2B 2578 -CORO6 1071 -CORO7 0 -CORO7-PAM16 0 -CORT 98 -COTL1 4573 -COX10 217 -COX10-AS1 69 -COX11 696 -COX14 938 -COX15 977 -COX16 92 -COX17 1121 -COX18 386 -COX19 1062 -COX20 204 -COX4I1 8835 -COX4I2 24 -COX5A 1824 -COX5B 4254 -COX6A1 3244 -COX6A2 38 -COX6B1 3639 -COX6B2 12 -COX6C 2423 -COX7A1 738 -COX7A2 2716 -COX7A2L 2693 -COX7B 1776 -COX7B2 0 -COX7C 4300 -COX8A 2411 -COX8C 0 -CP 4474 -CPA1 1 -CPA2 7 -CPA3 4 -CPA4 68 -CPA5 9 -CPA6 1 -CPAMD8 1058 -CPB1 3 -CPB2 0 -CPB2-AS1 94 -CPD 2162 -CPE 37336 -CPEB1 48 -CPEB1-AS1 109 -CPEB2 1894 -CPEB2-AS1 1 -CPEB3 995 -CPEB4 4805 -CPED1 292 -CPLX1 1267 -CPLX2 6024 -CPLX3 84 -CPLX4 2 -CPM 767 -CPN1 0 -CPN2 0 -CPNE1 2567 -CPNE2 2807 -CPNE3 3138 -CPNE4 671 -CPNE5 921 -CPNE6 1161 -CPNE7 622 -CPNE8 764 -CPNE9 222 -CPO 64 -CPOX 805 -CPPED1 603 -CPQ 1938 -CPS1 238 -CPS1-IT1 2 -CPSF1 3746 -CPSF2 1372 -CPSF3 641 -CPSF3L 2802 -CPSF4 1085 -CPSF4L 3 -CPSF6 2873 -CPSF7 4931 -CPT1A 4649 -CPT1B 132 -CPT1C 2294 -CPT2 420 -CPTP 817 -CPVL 748 -CPXCR1 0 -CPXM1 30 -CPXM2 1295 -CPZ 123 -CR1 12 -CR1L 2 -CR2 2 -CRABP1 278 -CRABP2 556 -CRACR2A 40 -CRACR2B 122 -CRADD 207 -CRAMP1L 1949 -CRAT 1910 -CRAT37 0 -CRAT40 1 -CRAT8 0 -CRB1 245 -CRB2 1234 -CRB3 12 -CRBN 1485 -CRCP 1910 -CRCT1 0 -CREB1 1979 -CREB3 2098 -CREB3L1 490 -CREB3L2 1864 -CREB3L3 31 -CREB3L4 186 -CREB5 713 -CREBBP 8213 -CREBL2 4087 -CREBRF 2392 -CREBZF 2203 -CREG1 1896 -CREG2 132 -CRELD1 5989 -CRELD2 2200 -CREM 2786 -CRH 102 -CRHBP 100 -CRHR1 0 -CRHR1-IT1 29 -CRHR2 106 -CRIM1 2380 -CRIP1 396 -CRIP2 8271 -CRIP3 74 -CRIPAK 559 -CRIPT 1018 -CRISP1 0 -CRISP2 5 -CRISP3 0 -CRISPLD1 313 -CRISPLD2 630 -CRK 149 -CRKL 4249 -CRLF1 1718 -CRLF2 0 -CRLF3 982 -CRLS1 699 -CRMP1 4465 -CRNDE 251 -CRNKL1 899 -CRNN 1 -CROCC 3412 -CROCCP2 1086 -CROCCP3 1594 -CROT 422 -CRP 0 -CRSP8P 74 -CRTAC1 940 -CRTAM 23 -CRTAP 7714 -CRTC1 3157 -CRTC2 2482 -CRTC3 2184 -CRTC3-AS1 4 -CRX 0 -CRY1 915 -CRY2 2067 -CRYAA 1 -CRYAB 49421 -CRYBA1 6 -CRYBA2 5 -CRYBA4 2 -CRYBB1 7 -CRYBB2 27 -CRYBB2P1 343 -CRYBB3 11 -CRYBG3 459 -CRYGA 4 -CRYGB 0 -CRYGC 0 -CRYGD 21 -CRYGN 50 -CRYGS 185 -CRYL1 1525 -CRYM 615 -CRYM-AS1 23 -CRYZ 1832 -CRYZL1 937 -CS 3180 -CSAD 1467 -CSAG1 5 -CSAG3 0 -CSAG4 1 -CSDC2 2190 -CSDE1 16486 -CSE1L 1943 -CSE1L-AS1 0 -CSF1 3499 -CSF1R 2072 -CSF2 0 -CSF2RA 45 -CSF2RB 186 -CSF3 132 -CSF3R 664 -CSGALNACT1 1103 -CSGALNACT2 1233 -CSH1 0 -CSH2 1 -CSHL1 0 -CSK 2143 -CSMD1 700 -CSMD2 1476 -CSMD2-AS1 0 -CSMD3 653 -CSN1S1 212 -CSN1S2AP 9 -CSN1S2BP 0 -CSN2 14 -CSN3 0 -CSNK1A1 3560 -CSNK1A1L 53 -CSNK1A1P1 19 -CSNK1D 4777 -CSNK1E 75 -CSNK1G1 1154 -CSNK1G2 3863 -CSNK1G2-AS1 22 -CSNK1G3 962 -CSNK2A1 1286 -CSNK2A2 1028 -CSNK2A3 232 -CSNK2B 119 -CSPG4 1702 -CSPG4P1Y 0 -CSPG5 2115 -CSPP1 2105 -CSRNP1 3065 -CSRNP2 3245 -CSRNP3 1423 -CSRP1 13381 -CSRP2 1000 -CSRP2BP 903 -CSRP3 3 -CST1 27 -CST11 0 -CST13P 0 -CST2 94 -CST3 50845 -CST4 1 -CST5 0 -CST6 25 -CST7 17 -CST8 1 -CST9 0 -CST9L 0 -CSTA 15 -CSTB 3505 -CSTF1 439 -CSTF2 370 -CSTF2T 1177 -CSTF3 1284 -CSTF3-AS1 4 -CSTL1 0 -CT45A1 1 -CT45A10 3 -CT45A2 0 -CT45A3 0 -CT45A4 0 -CT45A5 0 -CT45A6 0 -CT45A7 0 -CT45A8 0 -CT45A9 0 -CT47A1 0 -CT47A10 0 -CT47A11 0 -CT47A12 0 -CT47A2 0 -CT47A3 0 -CT47A4 0 -CT47A5 0 -CT47A6 0 -CT47A7 0 -CT47A8 0 -CT47A9 0 -CT47B1 0 -CT55 1 -CT62 1 -CT83 0 -CTAG1A 0 -CTAG1B 0 -CTAG2 0 -CTAGE1 2 -CTAGE10P 3 -CTAGE11P 3 -CTAGE15 0 -CTAGE4 0 -CTAGE5 578 -CTAGE6 2 -CTAGE7P 61 -CTAGE8 4 -CTAGE9 2 -CTB-113P19.1 21 -CTB-12O2.1 14 -CTB-178M22.2 16 -CTB-7E3.1 0 -CTBP1 5930 -CTBP1-AS 228 -CTBP1-AS2 479 -CTBP2 2318 -CTBS 449 -CTC-338M12.4 62 -CTC-436P18.1 0 -CTC1 1364 -CTCF 2183 -CTCFL 19 -CTD-2151A2.1 0 -CTD-2194D22.4 0 -CTD-2201E9.1 4 -CTD-2201I18.1 60 -CTD-2270F17.1 3 -CTD-2297D10.2 3 -CTD-2350J17.1 0 -CTD-3080P12.3 4 -CTDNEP1 3014 -CTDP1 464 -CTDSP1 1887 -CTDSP2 4974 -CTDSPL 1953 -CTDSPL2 538 -CTF1 212 -CTGF 2032 -CTGLF12P 151 -CTH 175 -CTHRC1 52 -CTIF 5914 -CTLA4 10 -CTNNA1 7356 -CTNNA2 3163 -CTNNA3 377 -CTNNAL1 740 -CTNNB1 13380 -CTNNBIP1 1324 -CTNNBL1 930 -CTNND1 65 -CTNND2 9887 -CTNS 715 -CTPS1 668 -CTPS2 447 -CTR9 2233 -CTRB1 4 -CTRB2 0 -CTRC 3 -CTRL 83 -CTSA 2389 -CTSB 21661 -CTSC 4112 -CTSD 17753 -CTSE 0 -CTSF 4446 -CTSG 1 -CTSH 3596 -CTSK 640 -CTSL 2032 -CTSL3P 2 -CTSLP2 14 -CTSLP8 0 -CTSO 0 -CTSS 1265 -CTSV 22 -CTSW 33 -CTSZ 7086 -CTTN 5386 -CTTNBP2 1122 -CTTNBP2NL 1279 -CTU1 459 -CTU2 435 -CTXN1 7775 -CTXN2 228 -CTXN3 56 -CUBN 780 -CUEDC1 1773 -CUEDC2 1577 -CUL1 2610 -CUL2 1260 -CUL3 3009 -CUL4A 1985 -CUL4B 2456 -CUL5 1590 -CUL7 1713 -CUL9 1983 -CUTA 0 -CUTC 365 -CUX1 4901 -CUX2 83 -CUZD1 0 -CWC15 1789 -CWC22 1263 -CWC25 225 -CWC27 1697 -CWF19L1 645 -CWF19L2 2248 -CWH43 2 -CX3CL1 3086 -CX3CR1 198 -CXADR 607 -CXADRP2 0 -CXADRP3 0 -CXCL1 336 -CXCL10 687 -CXCL11 638 -CXCL12 893 -CXCL13 6 -CXCL14 3186 -CXCL16 849 -CXCL17 2 -CXCL2 655 -CXCL3 60 -CXCL5 121 -CXCL6 10 -CXCL8 244 -CXCL9 93 -CXCR1 24 -CXCR2 17 -CXCR2P1 5 -CXCR3 22 -CXCR4 961 -CXCR5 7 -CXCR6 10 -CXXC1 2138 -CXXC1P1 0 -CXXC4 1229 -CXXC5 839 -CXorf21 94 -CXorf23 704 -CXorf36 942 -CXorf38 498 -CXorf40A 154 -CXorf40B 186 -CXorf49 0 -CXorf49B 0 -CXorf51A 0 -CXorf51B 0 -CXorf56 504 -CXorf57 1766 -CXorf58 6 -CXorf65 0 -CXorf66 0 -CXorf67 76 -CYB561 3929 -CYB561A3 802 -CYB561D1 467 -CYB561D2 188 -CYB5A 497 -CYB5B 2715 -CYB5D1 1475 -CYB5D2 1456 -CYB5R1 1139 -CYB5R2 88 -CYB5R3 9415 -CYB5R4 275 -CYB5RL 142 -CYBA 1806 -CYBB 784 -CYBRD1 7159 -CYC1 2047 -CYCS 3001 -CYCSP52 3 -CYFIP1 1485 -CYFIP2 5536 -CYGB 735 -CYHR1 2514 -CYLC1 1 -CYLC2 1 -CYLD 4201 -CYMP 0 -CYP11A1 110 -CYP11B1 0 -CYP11B2 0 -CYP17A1 6 -CYP19A1 49 -CYP1A1 28 -CYP1A2 1 -CYP1B1 2807 -CYP1B1-AS1 16 -CYP20A1 2266 -CYP21A1P 72 -CYP21A2 1 -CYP24A1 24 -CYP26A1 45 -CYP26B1 318 -CYP26C1 1 -CYP27A1 2177 -CYP27B1 42 -CYP27C1 13 -CYP2A13 0 -CYP2A6 21 -CYP2A7 11 -CYP2B6 0 -CYP2B7P 15 -CYP2C18 5 -CYP2C19 3 -CYP2C8 106 -CYP2C9 0 -CYP2D6 0 -CYP2D7 11 -CYP2E1 257 -CYP2F1 4 -CYP2G1P 12 -CYP2J2 699 -CYP2R1 176 -CYP2S1 199 -CYP2U1 1004 -CYP2W1 6 -CYP39A1 397 -CYP3A4 12 -CYP3A43 2 -CYP3A5 59 -CYP3A7 7 -CYP3A7-CYP3A51P 3 -CYP46A1 2032 -CYP4A11 3 -CYP4A22 2 -CYP4B1 934 -CYP4F11 192 -CYP4F12 161 -CYP4F2 3 -CYP4F22 0 -CYP4F24P 276 -CYP4F29P 65 -CYP4F3 31 -CYP4F30P 0 -CYP4F35P 43 -CYP4F62P 4 -CYP4F8 1 -CYP4V2 939 -CYP4X1 607 -CYP4Z1 47 -CYP4Z2P 14 -CYP51A1 2123 -CYP51A1-AS1 25 -CYP7A1 1 -CYP7B1 295 -CYP8B1 10 -CYR61 4102 -CYS1 297 -CYSLTR1 44 -CYSLTR2 552 -CYSRT1 79 -CYSTM1 2882 -CYTH1 2273 -CYTH2 2858 -CYTH3 1468 -CYTH4 227 -CYTIP 80 -CYTL1 158 -CYYR1 610 -D21S2088E 13 -D2HGDH 726 -DAAM1 3024 -DAAM2 5797 -DAB1 135 -DAB1-AS1 0 -DAB2 1786 -DAB2IP 4693 -DACH1 280 -DACH2 332 -DACT1 467 -DACT2 42 -DACT3 1865 -DACT3-AS1 38 -DAD1 2196 -DAG1 3292 -DAGLA 1036 -DAGLB 1290 -DALRD3 387 -DANCR 1273 -DAND5 5 -DANT2 86 -DAO 49 -DAOA 0 -DAOA-AS1 0 -DAP 2339 -DAP3 1694 -DAPK1 3226 -DAPK2 141 -DAPK3 1776 -DAPL1 50 -DAPP1 52 -DARS 2278 -DARS-AS1 10 -DARS2 338 -DAW1 112 -DAXX 17 -DAZ1 0 -DAZ2 0 -DAZ3 0 -DAZ4 0 -DAZAP1 2967 -DAZAP2 3997 -DAZL 4 -DBET 0 -DBF4 147 -DBF4B 810 -DBH 54 -DBH-AS1 212 -DBI 3356 -DBIL5P 68 -DBIL5P2 19 -DBN1 6799 -DBNDD1 1279 -DBNDD2 363 -DBNL 1930 -DBP 986 -DBR1 233 -DBT 1736 -DBX1 0 -DBX2 128 -DCAF10 1698 -DCAF11 2343 -DCAF12 1201 -DCAF12L1 10 -DCAF12L2 168 -DCAF13 524 -DCAF13P3 27 -DCAF15 702 -DCAF16 846 -DCAF17 866 -DCAF4 184 -DCAF4L1 173 -DCAF4L2 0 -DCAF5 5603 -DCAF6 1560 -DCAF7 4750 -DCAF8 3994 -DCAF8L1 0 -DCAF8L2 0 -DCAKD 2658 -DCANP1 2 -DCBLD1 44 -DCBLD2 1908 -DCC 253 -DCD 0 -DCDC1 13 -DCDC2 139 -DCDC2B 46 -DCDC2C 13 -DCDC5 162 -DCHS1 2719 -DCHS2 430 -DCK 616 -DCLK1 6768 -DCLK2 3979 -DCLK3 72 -DCLRE1A 396 -DCLRE1B 465 -DCLRE1C 716 -DCN 6466 -DCP1A 2261 -DCP1B 503 -DCP2 1002 -DCPS 215 -DCST1 7 -DCST2 44 -DCSTAMP 5 -DCT 46 -DCTD 1991 -DCTN1 11128 -DCTN1-AS1 63 -DCTN2 3605 -DCTN3 1571 -DCTN4 3179 -DCTN5 2034 -DCTN6 1092 -DCTPP1 294 -DCUN1D1 893 -DCUN1D2 694 -DCUN1D3 544 -DCUN1D4 2109 -DCUN1D5 2218 -DCX 380 -DCXR 1707 -DDA1 2391 -DDAH1 5957 -DDAH2 0 -DDB1 5672 -DDB2 317 -DDC 48 -DDC-AS1 0 -DDHD1 1163 -DDHD2 2293 -DDI1 1 -DDI2 58 -DDIAS 21 -DDIT3 4636 -DDIT4 7402 -DDIT4L 246 -DDN 830 -DDO 47 -DDOST 2986 -DDR1 34 -DDR2 766 -DDRGK1 2254 -DDT 0 -DDTL 0 -DDX1 2001 -DDX10 901 -DDX11 268 -DDX11-AS1 19 -DDX11L1 0 -DDX11L10 0 -DDX11L16 0 -DDX11L2 44 -DDX11L5 1 -DDX11L9 3 -DDX12P 91 -DDX17 26109 -DDX18 1582 -DDX19A 1004 -DDX19B 317 -DDX20 353 -DDX21 2955 -DDX23 3069 -DDX24 117 -DDX25 595 -DDX26B 428 -DDX26B-AS1 5 -DDX27 2307 -DDX28 149 -DDX31 408 -DDX39A 1053 -DDX39B 0 -DDX3X 9783 -DDX3Y 2 -DDX4 6 -DDX41 1638 -DDX42 3740 -DDX43 15 -DDX46 2904 -DDX47 947 -DDX49 920 -DDX5 22366 -DDX50 833 -DDX51 1389 -DDX52 59 -DDX53 0 -DDX54 1301 -DDX55 951 -DDX56 1886 -DDX58 689 -DDX59 517 -DDX6 5780 -DDX60 339 -DDX60L 383 -DEAF1 1540 -DEAR 0 -DEC1 0 -DECR1 1026 -DECR2 0 -DEDD 1175 -DEDD2 7618 -DEF6 554 -DEF8 3137 -DEFA1 0 -DEFA10P 0 -DEFA11P 0 -DEFA1B 0 -DEFA3 1 -DEFA4 0 -DEFA5 0 -DEFA6 0 -DEFA8P 0 -DEFA9P 0 -DEFB1 16 -DEFB103A 0 -DEFB103B 0 -DEFB104A 0 -DEFB104B 0 -DEFB105A 0 -DEFB105B 0 -DEFB106A 0 -DEFB106B 0 -DEFB107A 0 -DEFB107B 0 -DEFB108B 0 -DEFB109P1 0 -DEFB109P1B 0 -DEFB110 0 -DEFB112 0 -DEFB113 0 -DEFB114 0 -DEFB115 0 -DEFB116 0 -DEFB118 0 -DEFB119 0 -DEFB121 0 -DEFB122 0 -DEFB123 0 -DEFB124 1 -DEFB125 0 -DEFB126 0 -DEFB127 0 -DEFB128 0 -DEFB129 0 -DEFB130 0 -DEFB131 0 -DEFB132 0 -DEFB133 0 -DEFB134 7 -DEFB135 0 -DEFB136 0 -DEFB4A 0 -DEFB4B 0 -DEFT1P 0 -DEFT1P2 0 -DEGS1 2320 -DEGS2 79 -DEK 3193 -DENND1A 2353 -DENND1B 435 -DENND1C 250 -DENND2A 2380 -DENND2C 88 -DENND2D 133 -DENND3 1573 -DENND4A 1303 -DENND4B 3438 -DENND4C 1815 -DENND5A 5735 -DENND5B 2991 -DENND5B-AS1 12 -DENND6A 675 -DENND6B 1324 -DENR 1275 -DEPDC1 3 -DEPDC1-AS1 1 -DEPDC1B 12 -DEPDC4 12 -DEPDC5 416 -DEPDC7 58 -DEPTOR 1618 -DERA 512 -DERL1 1631 -DERL2 1125 -DERL3 0 -DES 232 -DESI1 1968 -DESI2 785 -DET1 156 -DEXI 1166 -DFFA 1723 -DFFB 430 -DFNA5 633 -DFNB31 3801 -DFNB59 96 -DGAT1 1475 -DGAT2 234 -DGAT2L6 2 -DGCR10 90 -DGCR11 49 -DGCR14 744 -DGCR2 4726 -DGCR5 835 -DGCR6 34 -DGCR6L 653 -DGCR8 1432 -DGCR9 302 -DGKA 457 -DGKB 816 -DGKD 1745 -DGKE 1506 -DGKG 798 -DGKH 1218 -DGKI 189 -DGKK 581 -DGKQ 1364 -DGKZ 1922 -DGUOK 1226 -DGUOK-AS1 19 -DHCR24 6154 -DHCR7 1781 -DHDDS 780 -DHDH 67 -DHFR 288 -DHFRL1 297 -DHH 24 -DHODH 204 -DHPS 1532 -DHRS1 259 -DHRS11 0 -DHRS12 249 -DHRS13 722 -DHRS2 102 -DHRS3 2177 -DHRS4 167 -DHRS4-AS1 671 -DHRS4L1 82 -DHRS4L2 175 -DHRS7 1918 -DHRS7B 444 -DHRS7C 3 -DHRS9 34 -DHRSX 0 -DHTKD1 868 -DHX15 2440 -DHX16 15 -DHX29 1134 -DHX30 3574 -DHX32 605 -DHX33 549 -DHX34 1784 -DHX35 261 -DHX36 1033 -DHX37 507 -DHX38 2310 -DHX40 1383 -DHX57 500 -DHX58 406 -DHX8 977 -DHX9 4245 -DIABLO 1622 -DIAPH1 3042 -DIAPH2 347 -DIAPH2-AS1 1 -DIAPH3 189 -DIAPH3-AS1 0 -DIAPH3-AS2 0 -DICER1 3190 -DICER1-AS1 299 -DIDO1 4254 -DIEXF 616 -DIMT1 445 -DIO1 7 -DIO2 1624 -DIO2-AS1 0 -DIO3 12 -DIO3OS 17 -DIP2A 2302 -DIP2A-IT1 1 -DIP2B 2616 -DIP2C 2289 -DIRAS1 1213 -DIRAS2 1073 -DIRAS3 7032 -DIRC1 0 -DIRC2 437 -DIRC3 46 -DIS3 854 -DIS3L 1318 -DIS3L2 748 -DISC1 36 -DISC1-IT1 5 -DISC1FP1 0 -DISC2 15 -DISP1 720 -DISP2 1077 -DIXDC1 2625 -DKC1 1712 -DKFZP434A062 41 -DKFZP434H168 14 -DKFZP434I0714 256 -DKFZP434K028 15 -DKFZP434L187 0 -DKFZP586I1420 394 -DKFZp434J0226 56 -DKFZp434L192 0 -DKFZp451B082 79 -DKFZp686K1684 0 -DKFZp779M0652 21 -DKK1 88 -DKK2 59 -DKK3 16601 -DKK4 2 -DKKL1 12 -DLAT 1191 -DLC1 2605 -DLD 1234 -DLEC1 1069 -DLEU1 120 -DLEU1-AS1 2 -DLEU2 106 -DLEU2L 26 -DLEU7 57 -DLEU7-AS1 11 -DLG1 2519 -DLG1-AS1 1 -DLG2 2711 -DLG3 1241 -DLG3-AS1 0 -DLG4 13358 -DLG5 0 -DLG5-AS1 0 -DLGAP1 1744 -DLGAP1-AS1 426 -DLGAP1-AS2 131 -DLGAP1-AS3 45 -DLGAP1-AS4 11 -DLGAP1-AS5 19 -DLGAP2 2 -DLGAP2-AS1 0 -DLGAP3 1003 -DLGAP4 4527 -DLGAP4-AS1 16 -DLGAP5 5 -DLK1 2222 -DLK2 108 -DLL1 0 -DLL3 263 -DLL4 429 -DLST 1832 -DLSTP1 60 -DLX1 599 -DLX2 97 -DLX2-AS1 0 -DLX3 9 -DLX4 8 -DLX5 213 -DLX6 245 -DLX6-AS1 87 -DMAP1 1099 -DMBT1 19 -DMBT1P1 1 -DMBX1 3 -DMC1 22 -DMD 1701 -DMGDH 191 -DMKN 336 -DMP1 3 -DMPK 5780 -DMRT1 0 -DMRT2 17 -DMRT3 0 -DMRTA1 42 -DMRTA2 5 -DMRTB1 0 -DMRTC1 0 -DMRTC1B 0 -DMRTC2 0 -DMTF1 3396 -DMTN 6918 -DMWD 4129 -DMXL1 1362 -DMXL2 1784 -DNA2 352 -DNAAF1 1324 -DNAAF2 479 -DNAAF3 179 -DNAAF5 904 -DNAH1 1103 -DNAH10 46 -DNAH11 552 -DNAH12 404 -DNAH14 212 -DNAH17 481 -DNAH17-AS1 11 -DNAH2 422 -DNAH3 149 -DNAH5 657 -DNAH6 452 -DNAH7 536 -DNAH8 5 -DNAH9 1736 -DNAI1 213 -DNAI2 114 -DNAJA1 23758 -DNAJA1P5 0 -DNAJA2 2672 -DNAJA3 1 -DNAJA4 21637 -DNAJB1 169621 -DNAJB11 3046 -DNAJB12 1760 -DNAJB13 49 -DNAJB14 1500 -DNAJB2 19466 -DNAJB3 0 -DNAJB4 6366 -DNAJB5 1646 -DNAJB5-AS1 25 -DNAJB6 6668 -DNAJB7 5 -DNAJB8 1 -DNAJB8-AS1 0 -DNAJB9 2675 -DNAJC1 1632 -DNAJC10 2946 -DNAJC11 699 -DNAJC12 790 -DNAJC13 2083 -DNAJC14 1023 -DNAJC15 1815 -DNAJC16 1147 -DNAJC17 213 -DNAJC18 1571 -DNAJC19 672 -DNAJC2 1155 -DNAJC21 2247 -DNAJC22 85 -DNAJC24 711 -DNAJC25 464 -DNAJC25-GNG10 0 -DNAJC27 535 -DNAJC27-AS1 155 -DNAJC28 0 -DNAJC3 3842 -DNAJC3-AS1 609 -DNAJC30 720 -DNAJC4 1033 -DNAJC5 7044 -DNAJC5B 6 -DNAJC5G 0 -DNAJC6 4366 -DNAJC7 3035 -DNAJC8 3162 -DNAJC9 629 -DNAJC9-AS1 81 -DNAL1 2664 -DNAL4 879 -DNALI1 2890 -DNASE1 713 -DNASE1L1 421 -DNASE1L2 381 -DNASE1L3 31 -DNASE2 872 -DNASE2B 64 -DND1 233 -DNER 8840 -DNHD1 1397 -DNLZ 362 -DNM1 9961 -DNM1L 3254 -DNM1P35 14 -DNM1P41 4 -DNM1P46 59 -DNM2 4597 -DNM3 2606 -DNM3-IT1 12 -DNM3OS 338 -DNMBP 883 -DNMBP-AS1 17 -DNMT1 2500 -DNMT3A 954 -DNMT3B 76 -DNMT3L 3 -DNPEP 777 -DNPH1 825 -DNTT 2 -DNTTIP1 670 -DNTTIP2 3498 -DOC2A 1274 -DOC2B 34 -DOC2GP 5 -DOCK1 2970 -DOCK10 1458 -DOCK11 914 -DOCK2 496 -DOCK3 2460 -DOCK4 2005 -DOCK4-AS1 8 -DOCK5 938 -DOCK6 1647 -DOCK7 1921 -DOCK8 705 -DOCK9 4344 -DOCK9-AS1 4 -DOCK9-AS2 23 -DOHH 883 -DOK1 497 -DOK2 369 -DOK3 448 -DOK4 905 -DOK5 692 -DOK6 1659 -DOK7 99 -DOLK 310 -DOLPP1 499 -DONSON 805 -DOPEY1 643 -DOPEY2 443 -DOT1L 1805 -DPAGT1 760 -DPCD 681 -DPCR1 0 -DPEP1 28 -DPEP2 38 -DPEP3 11 -DPF1 1525 -DPF2 2291 -DPF3 465 -DPH1 611 -DPH2 336 -DPH3 1599 -DPH3P1 156 -DPH5 535 -DPH6 98 -DPH6-AS1 87 -DPH7 690 -DPM1 513 -DPM2 818 -DPM3 455 -DPP10 659 -DPP10-AS1 53 -DPP10-AS3 0 -DPP3 578 -DPP4 13 -DPP6 4823 -DPP7 7475 -DPP8 687 -DPP9 1950 -DPP9-AS1 89 -DPPA2 0 -DPPA2P3 0 -DPPA3 0 -DPPA4 5 -DPPA5 1 -DPRX 1 -DPRXP4 19 -DPT 8 -DPY19L1 1125 -DPY19L1P1 79 -DPY19L2 424 -DPY19L2P1 74 -DPY19L2P2 106 -DPY19L2P3 7 -DPY19L2P4 115 -DPY19L3 1375 -DPY19L4 736 -DPY30 881 -DPYD 675 -DPYD-AS1 1 -DPYD-AS2 0 -DPYS 27 -DPYSL2 22654 -DPYSL3 11394 -DPYSL4 1413 -DPYSL5 2186 -DQX1 21 -DR1 1230 -DRAIC 27 -DRAM1 353 -DRAM2 794 -DRAP1 3127 -DRAXIN 58 -DRC1 704 -DRC7 281 -DRD1 61 -DRD2 575 -DRD3 0 -DRD4 5 -DRD5 19 -DRD5P2 0 -DRG1 938 -DRG2 1140 -DRGX 0 -DRICH1 26 -DROSHA 1792 -DRP2 567 -DSC1 3 -DSC2 177 -DSC3 3 -DSCAM 932 -DSCAM-AS1 7 -DSCAM-IT1 3 -DSCAML1 600 -DSCAS 0 -DSCC1 39 -DSCR10 0 -DSCR3 968 -DSCR4 0 -DSCR8 0 -DSCR9 35 -DSE 868 -DSEL 1 -DSG1 2 -DSG1-AS1 0 -DSG2 52 -DSG2-AS1 0 -DSG3 1 -DSG4 0 -DSN1 163 -DSP 937 -DSPP 0 -DST 22569 -DSTN 5412 -DSTNP2 365 -DSTYK 3293 -DTD1 919 -DTD2 412 -DTHD1 140 -DTL 9 -DTNA 33535 -DTNB 897 -DTNBP1 1294 -DTWD1 407 -DTWD2 288 -DTX1 2077 -DTX2 119 -DTX2P1-UPK3BP1-PMS2P11 84 -DTX3 5687 -DTX3L 1570 -DTX4 1834 -DTYMK 343 -DUOX1 260 -DUOX2 28 -DUOXA1 23 -DUOXA2 2 -DUPD1 0 -DUS1L 1323 -DUS2 142 -DUS3L 519 -DUS4L 120 -DUSP1 8220 -DUSP10 262 -DUSP11 405 -DUSP12 414 -DUSP13 3 -DUSP14 4 -DUSP15 217 -DUSP16 2552 -DUSP18 863 -DUSP19 271 -DUSP2 705 -DUSP21 0 -DUSP22 1784 -DUSP23 432 -DUSP26 2317 -DUSP27 33 -DUSP28 150 -DUSP3 4962 -DUSP4 956 -DUSP5 389 -DUSP5P1 6 -DUSP6 834 -DUSP7 876 -DUSP8 20 -DUSP9 25 -DUT 2170 -DUX4 0 -DUXA 0 -DUXAP10 6 -DUXAP8 1 -DVL1 5654 -DVL2 1379 -DVL3 4777 -DXO 6 -DYDC1 0 -DYDC2 93 -DYM 832 -DYNAP 1 -DYNC1H1 18987 -DYNC1I1 1831 -DYNC1I2 2247 -DYNC1LI1 1344 -DYNC1LI2 14741 -DYNC2H1 1790 -DYNC2LI1 518 -DYNLL1 11303 -DYNLL2 5251 -DYNLRB1 6882 -DYNLRB2 199 -DYNLT1 776 -DYNLT3 2481 -DYRK1A 3516 -DYRK1B 1137 -DYRK2 495 -DYRK3 433 -DYRK4 648 -DYSF 732 -DYTN 2 -DYX1C1 39 -DYX1C1-CCPG1 1 -DZANK1 544 -DZIP1 3309 -DZIP1L 165 -DZIP3 3874 -E2F1 86 -E2F2 8 -E2F3 357 -E2F4 1898 -E2F5 235 -E2F6 276 -E2F7 13 -E2F8 1 -E4F1 1149 -EAF1 1575 -EAF2 48 -EAPP 1054 -EARS2 1231 -EBAG9 1148 -EBF1 351 -EBF2 54 -EBF3 201 -EBF4 1240 -EBI3 67 -EBLN1 0 -EBLN2 154 -EBLN3 1606 -EBNA1BP2 1434 -EBP 471 -EBPL 454 -ECD 681 -ECE1 6089 -ECE2 5098 -ECEL1 8726 -ECEL1P2 2 -ECH1 3175 -ECHDC1 1397 -ECHDC2 2021 -ECHDC3 117 -ECHS1 2301 -ECI1 1145 -ECI2 1198 -ECM1 557 -ECM2 1549 -ECRP 2 -ECSCR 135 -ECSIT 1353 -ECT2 121 -ECT2L 42 -EDA 142 -EDA2R 113 -EDAR 17 -EDARADD 24 -EDC3 980 -EDC4 2518 -EDDM3A 0 -EDDM3B 0 -EDEM1 1063 -EDEM2 469 -EDEM3 1894 -EDF1 5221 -EDIL3 2617 -EDN1 318 -EDN2 3 -EDN3 9431 -EDNRA 178 -EDNRB 5358 -EDNRB-AS1 23 -EDRF1 755 -EDRF1-AS1 2 -EEA1 1572 -EED 728 -EEF1A1 6621 -EEF1A2 18288 -EEF1B2 1292 -EEF1D 4 -EEF1DP3 4 -EEF1E1 320 -EEF1E1-BLOC1S5 0 -EEF1G 4609 -EEF2 47089 -EEF2K 1483 -EEF2KMT 59 -EEFSEC 474 -EEPD1 390 -EFCAB1 877 -EFCAB10 69 -EFCAB11 218 -EFCAB12 391 -EFCAB13 288 -EFCAB14 4524 -EFCAB14-AS1 1 -EFCAB2 813 -EFCAB3 0 -EFCAB5 28 -EFCAB6 462 -EFCAB6-AS1 30 -EFCAB7 912 -EFCAB9 2 -EFCC1 164 -EFEMP1 5030 -EFEMP2 2119 -EFHB 96 -EFHC1 1526 -EFHC2 351 -EFHD1 3407 -EFHD2 2678 -EFNA1 1045 -EFNA2 64 -EFNA3 653 -EFNA4 104 -EFNA5 1447 -EFNB1 1460 -EFNB2 1302 -EFNB3 2556 -EFR3A 2092 -EFR3B 3178 -EFS 1042 -EFTUD1 489 -EFTUD1P1 30 -EFTUD2 1503 -EGF 264 -EGFEM1P 195 -EGFL6 59 -EGFL7 1809 -EGFL8 2 -EGFLAM 153 -EGFLAM-AS2 0 -EGFLAM-AS4 0 -EGFR 719 -EGFR-AS1 12 -EGLN1 3387 -EGLN2 16 -EGLN3 691 -EGOT 3 -EGR1 9693 -EGR2 388 -EGR3 175 -EGR4 191 -EHBP1 3523 -EHBP1L1 2292 -EHD1 2149 -EHD2 3349 -EHD3 1525 -EHD4 417 -EHD4-AS1 5 -EHF 114 -EHHADH 251 -EHHADH-AS1 0 -EHMT1 2395 -EHMT1-IT1 12 -EHMT2 0 -EI24 2735 -EID1 7780 -EID2 844 -EID2B 266 -EID3 140 -EIF1 16591 -EIF1AD 1186 -EIF1AX 1381 -EIF1AX-AS1 0 -EIF1AY 0 -EIF1B 3444 -EIF1B-AS1 41 -EIF2A 1618 -EIF2AK1 3018 -EIF2AK2 2221 -EIF2AK3 944 -EIF2AK4 2316 -EIF2B1 1051 -EIF2B2 981 -EIF2B3 389 -EIF2B4 1202 -EIF2B5 1966 -EIF2B5-AS1 0 -EIF2D 742 -EIF2S1 1598 -EIF2S2 3097 -EIF2S3 2263 -EIF3A 7387 -EIF3B 3210 -EIF3C 0 -EIF3CL 0 -EIF3D 1641 -EIF3E 2900 -EIF3F 859 -EIF3G 3099 -EIF3H 3587 -EIF3I 2546 -EIF3IP1 31 -EIF3J 3281 -EIF3J-AS1 662 -EIF3K 2044 -EIF3L 4313 -EIF3M 1129 -EIF4A1 0 -EIF4A2 17299 -EIF4A3 801 -EIF4B 2470 -EIF4E 522 -EIF4E1B 29 -EIF4E2 1520 -EIF4E3 1799 -EIF4EBP1 495 -EIF4EBP2 4127 -EIF4EBP3 38 -EIF4ENIF1 1300 -EIF4G1 11495 -EIF4G2 25187 -EIF4G3 5369 -EIF4H 3105 -EIF5 15426 -EIF5A 2919 -EIF5A2 399 -EIF5AL1 96 -EIF5B 13882 -EIF6 1082 -ELAC1 169 -ELAC2 1213 -ELANE 0 -ELAVL1 3225 -ELAVL2 1056 -ELAVL3 12665 -ELAVL4 2962 -ELDR 0 -ELF1 1292 -ELF2 959 -ELF3 6 -ELF4 255 -ELF5 0 -ELFN1 217 -ELFN1-AS1 6 -ELFN2 1961 -ELK1 1882 -ELK2AP 0 -ELK3 891 -ELK4 1379 -ELL 709 -ELL2 1588 -ELL3 196 -ELMO1 2260 -ELMO1-AS1 1 -ELMO2 2575 -ELMO3 323 -ELMOD1 1254 -ELMOD2 736 -ELMOD3 890 -ELMSAN1 2896 -ELN 2329 -ELOF1 1621 -ELOVL1 1067 -ELOVL2 3657 -ELOVL2-AS1 176 -ELOVL3 5 -ELOVL4 734 -ELOVL5 6686 -ELOVL6 320 -ELOVL7 1187 -ELP2 866 -ELP3 903 -ELP4 374 -ELP5 1097 -ELP6 613 -ELSPBP1 0 -EMB 365 -EMBP1 50 -EMC1 2206 -EMC10 5189 -EMC2 1198 -EMC3 1501 -EMC3-AS1 225 -EMC4 1448 -EMC6 42 -EMC7 2345 -EMC8 730 -EMC9 492 -EMCN 534 -EMD 1491 -EME1 10 -EME2 123 -EMG1 450 -EMID1 361 -EMILIN1 2114 -EMILIN2 306 -EMILIN3 107 -EML1 732 -EML2 2452 -EML2-AS1 26 -EML3 1782 -EML4 1089 -EML5 448 -EML6 452 -EMP1 3283 -EMP2 1490 -EMP3 1070 -EMX1 2 -EMX2 1704 -EMX2OS 3195 -EN1 18 -EN2 131 -ENAH 8297 -ENAM 12 -ENC1 1945 -ENDOD1 2489 -ENDOG 390 -ENDOU 20 -ENDOV 453 -ENG 4155 -ENGASE 5181 -ENHO 3000 -ENKD1 1037 -ENKUR 877 -ENO1 17057 -ENO1-AS1 2 -ENO2 10060 -ENO3 125 -ENO4 196 -ENOPH1 1528 -ENOSF1 460 -ENOX1 338 -ENOX1-AS2 1 -ENOX2 565 -ENPEP 45 -ENPP1 144 -ENPP2 1744 -ENPP3 37 -ENPP4 1518 -ENPP5 2119 -ENPP6 512 -ENPP7 0 -ENPP7P13 0 -ENSA 4501 -ENTHD1 0 -ENTHD2 773 -ENTPD1 2412 -ENTPD1-AS1 16 -ENTPD2 1163 -ENTPD3 263 -ENTPD3-AS1 35 -ENTPD4 1499 -ENTPD5 115 -ENTPD6 3726 -ENTPD7 193 -ENTPD8 5 -ENY2 1098 -EOGT 575 -EOMES 9 -EP300 5300 -EP300-AS1 22 -EP400 3626 -EP400NL 173 -EPAS1 8805 -EPB41 1169 -EPB41L1 11214 -EPB41L2 6941 -EPB41L3 4583 -EPB41L4A 1090 -EPB41L4A-AS1 730 -EPB41L4A-AS2 33 -EPB41L4B 821 -EPB41L5 1884 -EPB42 1 -EPC1 1842 -EPC2 1709 -EPCAM 283 -EPDR1 4237 -EPG5 1541 -EPGN 35 -EPHA1 8 -EPHA1-AS1 10 -EPHA10 443 -EPHA2 694 -EPHA3 283 -EPHA4 1009 -EPHA5 282 -EPHA5-AS1 19 -EPHA6 34 -EPHA7 241 -EPHA8 68 -EPHB1 385 -EPHB2 730 -EPHB3 317 -EPHB4 673 -EPHB6 363 -EPHX1 12953 -EPHX2 681 -EPHX3 65 -EPHX4 31 -EPM2A 783 -EPM2AIP1 4278 -EPN1 6444 -EPN2 3542 -EPN2-AS1 21 -EPN2-IT1 2 -EPN3 23 -EPO 19 -EPOR 896 -EPPIN 3 -EPPIN-WFDC6 4 -EPPK1 86 -EPRS 4193 -EPS15 3446 -EPS15L1 2267 -EPS8 1759 -EPS8L1 22 -EPS8L2 1199 -EPS8L3 0 -EPSTI1 225 -EPT1 1551 -EPX 20 -EPYC 1 -EQTN 1 -ERAL1 1022 -ERAP1 979 -ERAP2 166 -ERAS 101 -ERBB2 3221 -ERBB2IP 7445 -ERBB3 817 -ERBB4 3998 -ERC1 3890 -ERC2 515 -ERC2-IT1 38 -ERCC1 1823 -ERCC2 541 -ERCC3 1374 -ERCC4 849 -ERCC5 31 -ERCC6 438 -ERCC6-PGBD3 0 -ERCC6L 31 -ERCC6L2 811 -ERCC8 219 -EREG 1 -ERF 2846 -ERG 586 -ERGIC1 4587 -ERGIC2 1059 -ERGIC3 3410 -ERH 1790 -ERI1 434 -ERI2 180 -ERI3 2371 -ERI3-IT1 99 -ERICH1 808 -ERICH1-AS1 3 -ERICH2 305 -ERICH3 1938 -ERICH3-AS1 1 -ERICH4 6 -ERICH5 95 -ERICH6 3 -ERICH6-AS1 123 -ERICH6B 4 -ERLEC1 2149 -ERLIN1 970 -ERLIN2 1721 -ERMAP 622 -ERMARD 0 -ERMN 2293 -ERMP1 989 -ERN1 289 -ERN2 14 -ERO1A 1684 -ERO1B 823 -ERP27 94 -ERP29 3578 -ERP44 2020 -ERRFI1 2159 -ERV3-1 562 -ERVFRD-1 8 -ERVH48-1 55 -ERVK13-1 527 -ERVMER34-1 27 -ERVV-1 6 -ERVV-2 1 -ERVW-1 43 -ESAM 1668 -ESCO1 526 -ESCO2 2 -ESD 1825 -ESF1 4070 -ESM1 30 -ESPL1 6 -ESPN 28 -ESPNL 28 -ESPNP 3 -ESR1 549 -ESR2 67 -ESRG 11 -ESRP1 1 -ESRP2 48 -ESRRA 807 -ESRRB 31 -ESRRG 314 -ESX1 0 -ESYT1 2340 -ESYT2 3439 -ESYT3 761 -ETAA1 254 -ETF1 3159 -ETFA 963 -ETFB 1685 -ETFDH 648 -ETHE1 429 -ETNK1 2783 -ETNK2 664 -ETNPPL 2898 -ETS1 1181 -ETS2 4529 -ETV1 2138 -ETV2 17 -ETV3 211 -ETV3L 3 -ETV4 288 -ETV5 1682 -ETV6 1437 -ETV7 71 -EVA1A 31 -EVA1B 622 -EVA1C 991 -EVADR 0 -EVC 760 -EVC2 692 -EVI2A 698 -EVI2B 582 -EVI5 1163 -EVI5L 2489 -EVL 5481 -EVPL 29 -EVPLL 2 -EVX1 1 -EVX1-AS 0 -EVX2 0 -EWSAT1 35 -EWSR1 7043 -EXD1 4 -EXD2 1429 -EXD3 776 -EXO1 2 -EXO5 97 -EXOC1 1247 -EXOC2 1214 -EXOC3 1743 -EXOC3-AS1 210 -EXOC3L1 59 -EXOC3L2 80 -EXOC3L4 0 -EXOC4 1794 -EXOC5 2200 -EXOC6 424 -EXOC6B 410 -EXOC7 5282 -EXOC8 747 -EXOG 870 -EXOSC1 348 -EXOSC10 1715 -EXOSC2 591 -EXOSC3 506 -EXOSC4 357 -EXOSC5 241 -EXOSC6 844 -EXOSC7 643 -EXOSC8 269 -EXOSC9 198 -EXPH5 493 -EXT1 615 -EXT2 1538 -EXTL1 312 -EXTL2 768 -EXTL3 2524 -EXTL3-AS1 14 -EYA1 162 -EYA2 602 -EYA3 1724 -EYA4 256 -EYS 69 -EZH1 4077 -EZH2 73 -EZR 5181 -EZR-AS1 3 -F10 127 -F10-AS1 0 -F11 14 -F11-AS1 0 -F11R 1001 -F12 72 -F13A1 630 -F13B 0 -F2 6 -F2R 223 -F2RL1 39 -F2RL2 50 -F2RL3 85 -F3 3367 -F5 988 -F7 64 -F8 499 -F8A1 173 -F8A2 0 -F8A3 0 -F9 0 -FA2H 573 -FAAH 636 -FAAH2 136 -FAAHP1 26 -FAAP100 503 -FAAP20 1964 -FAAP24 22 -FABP1 13 -FABP12 0 -FABP2 1 -FABP3 801 -FABP4 30 -FABP5 66 -FABP5P3 4 -FABP6 311 -FABP7 859 -FABP9 0 -FADD 395 -FADS1 3301 -FADS2 5850 -FADS3 1800 -FADS6 101 -FAF1 938 -FAF2 2061 -FAH 390 -FAHD1 874 -FAHD2A 219 -FAHD2B 297 -FAHD2CP 424 -FAIM 413 -FAIM2 23768 -FALEC 31 -FAM101A 0 -FAM101B 1029 -FAM102A 3364 -FAM102B 849 -FAM103A1 111 -FAM104A 989 -FAM104B 489 -FAM105A 275 -FAM106A 25 -FAM106B 16 -FAM106CP 3 -FAM107A 83087 -FAM107B 2667 -FAM109A 381 -FAM109B 12 -FAM110A 223 -FAM110B 1060 -FAM110C 254 -FAM110D 276 -FAM111A 640 -FAM111B 12 -FAM114A1 1221 -FAM114A2 623 -FAM117A 461 -FAM117B 997 -FAM118A 1980 -FAM118B 1135 -FAM120A 3752 -FAM120AOS 1465 -FAM120B 0 -FAM120C 1071 -FAM122A 841 -FAM122B 1816 -FAM122C 161 -FAM124A 636 -FAM124B 31 -FAM126A 1066 -FAM126B 2587 -FAM127A 7959 -FAM127B 1697 -FAM127C 361 -FAM129A 695 -FAM129B 6313 -FAM129C 29 -FAM131A 2220 -FAM131B 972 -FAM131C 130 -FAM132A 27 -FAM132B 9 -FAM133A 629 -FAM133B 734 -FAM133CP 77 -FAM133DP 4 -FAM134A 5016 -FAM134B 1748 -FAM134C 1618 -FAM135A 899 -FAM135B 761 -FAM136A 743 -FAM138A 0 -FAM138B 0 -FAM138C 0 -FAM138D 0 -FAM138E 0 -FAM138F 0 -FAM13A 1796 -FAM13A-AS1 361 -FAM13B 2111 -FAM13C 527 -FAM149A 443 -FAM149B1 958 -FAM150A 2 -FAM150B 215 -FAM151A 72 -FAM151B 103 -FAM153A 112 -FAM153B 162 -FAM153C 233 -FAM155A 1978 -FAM155A-IT1 88 -FAM155B 431 -FAM156A 25 -FAM156B 1 -FAM157A 2 -FAM157B 0 -FAM157C 3 -FAM159A 211 -FAM159B 347 -FAM160A1 90 -FAM160A2 866 -FAM160B1 924 -FAM160B2 2014 -FAM161A 593 -FAM161B 530 -FAM162A 959 -FAM162B 44 -FAM163A 11 -FAM163B 185 -FAM166A 4 -FAM166B 116 -FAM167A 1310 -FAM167A-AS1 46 -FAM167B 403 -FAM168A 6519 -FAM168B 5167 -FAM169A 2631 -FAM169B 0 -FAM170A 1 -FAM170B 2 -FAM170B-AS1 0 -FAM171A1 4185 -FAM171A2 2130 -FAM171B 2061 -FAM172A 1186 -FAM172BP 1 -FAM173A 940 -FAM173B 1069 -FAM174A 834 -FAM174B 523 -FAM175A 129 -FAM175B 724 -FAM177A1 1311 -FAM177B 12 -FAM178B 26 -FAM179A 1109 -FAM179B 1419 -FAM180A 7 -FAM180B 18 -FAM181A 0 -FAM181A-AS1 0 -FAM181B 1910 -FAM182A 37 -FAM182B 63 -FAM183A 147 -FAM183B 0 -FAM183CP 0 -FAM184A 1136 -FAM184B 324 -FAM185A 133 -FAM186A 16 -FAM186B 34 -FAM187B 3 -FAM188A 615 -FAM188B 4 -FAM189A1 107 -FAM189A2 1545 -FAM189B 3 -FAM192A 2797 -FAM193A 2781 -FAM193B 4087 -FAM195A 817 -FAM195B 3522 -FAM196A 187 -FAM196B 39 -FAM197Y2 0 -FAM197Y5 0 -FAM198A 196 -FAM198B 3013 -FAM199X 3497 -FAM19A1 74 -FAM19A2 246 -FAM19A3 16 -FAM19A4 44 -FAM19A5 3916 -FAM200A 455 -FAM200B 1733 -FAM201A 83 -FAM204A 872 -FAM205A 15 -FAM205BP 5 -FAM205C 2 -FAM206A 530 -FAM207A 224 -FAM208A 3156 -FAM208B 2246 -FAM209A 6 -FAM209B 3 -FAM20A 1601 -FAM20B 3554 -FAM20C 922 -FAM210A 380 -FAM210B 2879 -FAM212A 79 -FAM212B 269 -FAM212B-AS1 2 -FAM213A 5559 -FAM213B 95 -FAM214A 1318 -FAM214B 1059 -FAM215A 0 -FAM216A 468 -FAM216B 144 -FAM217A 1 -FAM217B 1095 -FAM218A 85 -FAM219A 6403 -FAM219B 4154 -FAM21A 703 -FAM21C 740 -FAM21EP 28 -FAM220A 688 -FAM221A 306 -FAM221B 7 -FAM222A 1778 -FAM222A-AS1 14 -FAM222B 1415 -FAM223A 0 -FAM223B 0 -FAM224A 0 -FAM224B 0 -FAM225A 27 -FAM225B 21 -FAM226A 0 -FAM226B 0 -FAM227A 1995 -FAM227B 45 -FAM228A 73 -FAM228B 611 -FAM229A 223 -FAM229B 1601 -FAM230B 1 -FAM230C 0 -FAM231A 0 -FAM231B 2 -FAM231C 0 -FAM231D 0 -FAM24A 1 -FAM24B 68 -FAM24B-CUZD1 1 -FAM25A 0 -FAM25BP 0 -FAM25C 0 -FAM25G 0 -FAM26D 1 -FAM26E 45 -FAM26F 109 -FAM27B 23 -FAM27C 1 -FAM27E2 7 -FAM27E3 36 -FAM27L 0 -FAM32A 1919 -FAM35A 406 -FAM35BP 33 -FAM35DP 9 -FAM3A 2185 -FAM3B 6 -FAM3C 862 -FAM3D 5 -FAM41AY1 0 -FAM41AY2 0 -FAM41C 6 -FAM43A 1036 -FAM43B 1295 -FAM45A 404 -FAM45B 117 -FAM46A 9048 -FAM46B 56 -FAM46C 210 -FAM46D 0 -FAM47A 2 -FAM47B 0 -FAM47C 5 -FAM47E 150 -FAM47E-STBD1 0 -FAM49A 1648 -FAM49B 1567 -FAM50A 2645 -FAM50B 823 -FAM53A 53 -FAM53B 2302 -FAM53B-AS1 7 -FAM53C 2648 -FAM57A 285 -FAM57B 979 -FAM58A 628 -FAM60A 0 -FAM63A 1203 -FAM63B 1658 -FAM64A 5 -FAM65A 4566 -FAM65B 1267 -FAM65C 540 -FAM66A 1 -FAM66B 40 -FAM66C 133 -FAM66D 56 -FAM66E 1 -FAM69A 856 -FAM69B 1146 -FAM69C 186 -FAM71A 1 -FAM71B 0 -FAM71C 0 -FAM71D 4 -FAM71E1 190 -FAM71E2 1 -FAM71F1 22 -FAM71F2 456 -FAM72A 7 -FAM72B 6 -FAM72C 0 -FAM72D 1 -FAM73A 1066 -FAM73B 1781 -FAM74A1 1 -FAM74A3 2 -FAM74A4 1 -FAM74A6 0 -FAM74A7 3 -FAM76A 389 -FAM76B 386 -FAM78A 287 -FAM78B 65 -FAM81A 513 -FAM81B 285 -FAM83A 3 -FAM83A-AS1 35 -FAM83B 1 -FAM83C 3 -FAM83C-AS1 3 -FAM83D 26 -FAM83E 55 -FAM83F 9 -FAM83G 229 -FAM83H 1 -FAM83H-AS1 4 -FAM84A 859 -FAM84B 1098 -FAM86B1 90 -FAM86B2 24 -FAM86B3P 27 -FAM86C1 61 -FAM86C2P 47 -FAM86DP 203 -FAM86EP 87 -FAM86FP 35 -FAM86HP 32 -FAM86JP 40 -FAM87A 9 -FAM87B 7 -FAM89A 819 -FAM89B 1394 -FAM8A1 3187 -FAM90A1 138 -FAM90A10P 0 -FAM90A25P 10 -FAM90A27P 0 -FAM90A2P 6 -FAM90A7P 0 -FAM91A1 1239 -FAM92A1 827 -FAM92A1P2 0 -FAM92B 353 -FAM95A 148 -FAM95B1 45 -FAM95C 309 -FAM96A 690 -FAM96B 1859 -FAM98A 1533 -FAM98B 1172 -FAM98C 523 -FAM99A 0 -FAM99B 0 -FAM9A 2 -FAM9B 3 -FAM9C 0 -FAN1 168 -FANCA 75 -FANCB 15 -FANCC 360 -FANCD2 48 -FANCD2OS 1 -FANCE 160 -FANCF 447 -FANCG 414 -FANCI 73 -FANCL 704 -FANCM 70 -FANK1 442 -FANK1-AS1 1 -FAP 66 -FAR1 2052 -FAR2 351 -FAR2P1 27 -FAR2P2 323 -FARP1 3337 -FARP2 854 -FARS2 272 -FARSA 1992 -FARSB 1202 -FAS 298 -FAS-AS1 2 -FASLG 6 -FASN 7717 -FASTK 1606 -FASTKD1 806 -FASTKD2 672 -FASTKD3 183 -FASTKD5 609 -FAT1 4423 -FAT2 92 -FAT3 5233 -FAT4 554 -FATE1 0 -FAU 3495 -FAXC 875 -FAXDC2 1919 -FBF1 1026 -FBL 1147 -FBLIM1 202 -FBLL1 1419 -FBLN1 4250 -FBLN2 652 -FBLN5 1232 -FBLN7 45 -FBN1 1105 -FBN2 55 -FBN3 66 -FBP1 117 -FBP2 1 -FBRS 4842 -FBRSL1 2280 -FBXL12 363 -FBXL13 44 -FBXL14 1645 -FBXL15 783 -FBXL16 8184 -FBXL17 1505 -FBXL18 2113 -FBXL19 2177 -FBXL19-AS1 473 -FBXL2 1392 -FBXL20 2256 -FBXL21 7 -FBXL22 27 -FBXL3 1598 -FBXL4 444 -FBXL5 2812 -FBXL6 456 -FBXL7 1115 -FBXL8 72 -FBXO10 1036 -FBXO11 3622 -FBXO15 148 -FBXO16 217 -FBXO17 647 -FBXO18 2381 -FBXO2 13230 -FBXO21 3688 -FBXO22 377 -FBXO22-AS1 0 -FBXO24 31 -FBXO25 439 -FBXO27 491 -FBXO28 1591 -FBXO3 1078 -FBXO3-AS1 0 -FBXO30 882 -FBXO31 3773 -FBXO32 1931 -FBXO33 1244 -FBXO34 744 -FBXO36 330 -FBXO38 909 -FBXO39 19 -FBXO4 161 -FBXO40 0 -FBXO41 3121 -FBXO42 1803 -FBXO43 5 -FBXO44 5252 -FBXO45 1095 -FBXO46 584 -FBXO47 1 -FBXO48 46 -FBXO5 167 -FBXO6 484 -FBXO7 3184 -FBXO8 839 -FBXO9 1683 -FBXW10 22 -FBXW11 3062 -FBXW12 9 -FBXW2 2190 -FBXW4 4187 -FBXW4P1 127 -FBXW5 3428 -FBXW7 1690 -FBXW8 743 -FBXW9 285 -FCAMR 0 -FCAR 0 -FCER1A 5 -FCER1G 462 -FCER2 4 -FCF1 935 -FCGBP 2702 -FCGR1A 41 -FCGR1B 14 -FCGR1C 30 -FCGR2A 1210 -FCGR2B 116 -FCGR2C 225 -FCGR3A 1296 -FCGR3B 27 -FCGRT 2998 -FCHO1 1194 -FCHO2 899 -FCHSD1 1602 -FCHSD2 2247 -FCMR 45 -FCN1 25 -FCN2 1 -FCN3 343 -FCRL1 1 -FCRL2 3 -FCRL3 0 -FCRL4 0 -FCRL5 39 -FCRL6 11 -FCRLA 4 -FCRLB 30 -FDCSP 5 -FDFT1 4391 -FDPS 1454 -FDPSP2 19 -FDX1 736 -FDX1L 971 -FDXACB1 85 -FDXR 269 -FECH 550 -FEM1A 1174 -FEM1B 2893 -FEM1C 1542 -FEN1 207 -FENDRR 170 -FER 1644 -FER1L4 493 -FER1L5 130 -FER1L6 9 -FER1L6-AS1 0 -FER1L6-AS2 8 -FERD3L 0 -FERMT1 175 -FERMT2 2204 -FERMT3 1194 -FES 624 -FETUB 0 -FEV 4 -FEZ1 7753 -FEZ2 1476 -FEZF1 652 -FEZF1-AS1 577 -FEZF2 58 -FFAR1 8 -FFAR2 10 -FFAR3 0 -FFAR4 91 -FGA 0 -FGB 1 -FGD1 959 -FGD2 434 -FGD3 186 -FGD4 1125 -FGD5 707 -FGD5-AS1 7497 -FGD5P1 36 -FGD6 1074 -FGF1 8318 -FGF10 21 -FGF10-AS1 16 -FGF11 312 -FGF12 1206 -FGF12-AS1 0 -FGF13 1440 -FGF13-AS1 14 -FGF14 1035 -FGF14-AS1 1 -FGF14-AS2 169 -FGF14-IT1 3 -FGF16 1 -FGF17 759 -FGF18 52 -FGF19 0 -FGF2 2777 -FGF20 13 -FGF21 0 -FGF22 34 -FGF23 5 -FGF3 0 -FGF4 0 -FGF5 2 -FGF6 0 -FGF7 11 -FGF8 20 -FGF9 73 -FGFBP1 0 -FGFBP2 10 -FGFBP3 381 -FGFR1 6647 -FGFR1OP 846 -FGFR1OP2 1910 -FGFR2 1547 -FGFR3 4474 -FGFR4 154 -FGFRL1 2825 -FGG 0 -FGGY 112 -FGL1 2 -FGL2 690 -FGR 692 -FH 759 -FHAD1 166 -FHDC1 565 -FHIT 192 -FHL1 11583 -FHL2 286 -FHL3 422 -FHL5 451 -FHOD1 909 -FHOD3 782 -FIBCD1 192 -FIBIN 306 -FIBP 1067 -FICD 427 -FIG4 975 -FIGF 8 -FIGLA 0 -FIGN 572 -FIGNL1 198 -FIGNL2 91 -FILIP1 493 -FILIP1L 722 -FIP1L1 1385 -FIRRE 11 -FIS1 2716 -FITM1 27 -FITM2 117 -FIZ1 1175 -FJX1 378 -FKBP10 2795 -FKBP11 853 -FKBP14 616 -FKBP15 1260 -FKBP1A 3388 -FKBP1A-SDCBP2 41 -FKBP1AP1 36 -FKBP1B 452 -FKBP2 4229 -FKBP3 2405 -FKBP4 25764 -FKBP5 4515 -FKBP6 0 -FKBP7 179 -FKBP8 22616 -FKBP9 1448 -FKBP9P1 184 -FKBPL 0 -FKRP 1027 -FKSG29 1 -FKTN 657 -FLAD1 718 -FLCN 3452 -FLG 28 -FLG-AS1 68 -FLG2 5 -FLI1 760 -FLII 4640 -FLJ10038 537 -FLJ12825 1 -FLJ13224 0 -FLJ16171 1 -FLJ16779 1244 -FLJ20021 292 -FLJ21408 2 -FLJ22447 7 -FLJ22763 0 -FLJ23867 405 -FLJ25758 0 -FLJ26245 0 -FLJ26850 51 -FLJ27354 28 -FLJ30679 1 -FLJ31104 11 -FLJ31356 4 -FLJ31662 0 -FLJ32255 88 -FLJ33360 76 -FLJ33534 11 -FLJ33581 0 -FLJ34503 6 -FLJ35934 10 -FLJ36000 1 -FLJ36777 25 -FLJ37035 54 -FLJ37201 59 -FLJ37453 398 -FLJ37505 6 -FLJ38122 0 -FLJ38576 23 -FLJ40194 0 -FLJ40288 0 -FLJ41200 89 -FLJ41278 51 -FLJ41941 0 -FLJ42102 0 -FLJ42351 13 -FLJ42393 25 -FLJ42627 160 -FLJ42969 7 -FLJ43315 1 -FLJ43879 0 -FLJ44635 74 -FLJ45079 5 -FLJ45513 51 -FLJ46066 1 -FLJ46284 0 -FLJ46906 269 -FLNA 23255 -FLNB 4563 -FLNC 2329 -FLOT1 3 -FLOT2 3728 -FLRT1 480 -FLRT2 1370 -FLRT3 241 -FLT1 4965 -FLT3 24 -FLT3LG 201 -FLT4 869 -FLVCR1 799 -FLVCR1-AS1 60 -FLVCR2 109 -FLYWCH1 2671 -FLYWCH2 1037 -FMN1 97 -FMN2 2669 -FMNL1 1536 -FMNL2 7628 -FMNL3 2272 -FMO1 0 -FMO2 391 -FMO3 54 -FMO4 83 -FMO5 104 -FMO6P 1 -FMO9P 0 -FMOD 749 -FMR1 2438 -FMR1-AS1 4 -FMR1NB 2 -FN1 14435 -FN3K 3236 -FN3KRP 1103 -FNBP1 5214 -FNBP1L 2335 -FNBP4 1841 -FNDC1 207 -FNDC3A 5883 -FNDC3B 1485 -FNDC4 1434 -FNDC5 434 -FNDC7 12 -FNDC8 32 -FNDC9 1814 -FNIP1 1038 -FNIP2 745 -FNTA 1716 -FNTB 20 -FOCAD 1778 -FOCAD-AS1 9 -FOLH1 41 -FOLH1B 1 -FOLR1 363 -FOLR2 76 -FOLR3 0 -FOPNL 100 -FOS 24632 -FOSB 815 -FOSL1 191 -FOSL2 6633 -FOXA1 57 -FOXA2 0 -FOXA3 2 -FOXB1 71 -FOXB2 2 -FOXC1 1530 -FOXC2 155 -FOXC2-AS1 0 -FOXCUT 19 -FOXD1 627 -FOXD2 127 -FOXD2-AS1 91 -FOXD3 36 -FOXD3-AS1 5 -FOXD4 44 -FOXD4L1 28 -FOXD4L3 2 -FOXD4L4 0 -FOXD4L5 3 -FOXD4L6 14 -FOXE1 1 -FOXE3 1 -FOXF1 802 -FOXF2 296 -FOXG1 34 -FOXG1-AS1 0 -FOXH1 6 -FOXI1 1 -FOXI2 90 -FOXI3 0 -FOXJ1 4507 -FOXJ2 1033 -FOXJ3 3125 -FOXK1 4272 -FOXK2 3117 -FOXL1 20 -FOXL2 114 -FOXL2NB 30 -FOXM1 71 -FOXN1 0 -FOXN2 537 -FOXN3 2651 -FOXN3-AS1 72 -FOXN3-AS2 1 -FOXN4 40 -FOXO1 1654 -FOXO3 1783 -FOXO3B 383 -FOXO4 3786 -FOXO6 369 -FOXP1 2425 -FOXP1-AS1 4 -FOXP2 392 -FOXP3 22 -FOXP4 2551 -FOXP4-AS1 13 -FOXQ1 226 -FOXR1 5 -FOXR2 0 -FOXRED1 862 -FOXRED2 1978 -FOXS1 29 -FPGS 669 -FPGT 299 -FPGT-TNNI3K 2 -FPR1 171 -FPR2 4 -FPR3 53 -FRA10AC1 2167 -FRAS1 264 -FRAT1 174 -FRAT2 332 -FREM1 477 -FREM2 51 -FREM3 6 -FRG1 1 -FRG1BP 193 -FRG1CP 189 -FRG1DP 3 -FRG1HP 217 -FRG1JP 110 -FRG2 0 -FRG2B 0 -FRG2C 1 -FRG2DP 0 -FRG2EP 0 -FRK 17 -FRMD1 1 -FRMD3 428 -FRMD4A 2381 -FRMD4B 702 -FRMD5 1585 -FRMD6 764 -FRMD6-AS1 65 -FRMD6-AS2 2 -FRMD7 0 -FRMD8 954 -FRMD8P1 10 -FRMPD1 132 -FRMPD2 204 -FRMPD2B 35 -FRMPD3 1703 -FRMPD3-AS1 2 -FRMPD4 431 -FRRS1 49 -FRRS1L 249 -FRS2 1546 -FRS3 938 -FRY 2279 -FRY-AS1 24 -FRYL 2233 -FRZB 10376 -FSBP 0 -FSCB 2 -FSCN1 2417 -FSCN2 49 -FSCN3 32 -FSD1 1088 -FSD1L 1671 -FSD2 187 -FSHB 8 -FSHR 1 -FSIP1 92 -FSIP2 57 -FST 314 -FSTL1 2703 -FSTL3 1045 -FSTL4 220 -FSTL5 389 -FTCD 98 -FTCDNL1 16 -FTH1 27385 -FTH1P18 0 -FTH1P3 51 -FTHL17 0 -FTL 49432 -FTLP10 0 -FTMT 0 -FTO 3240 -FTO-IT1 10 -FTSJ1 655 -FTSJ2 503 -FTSJ3 1401 -FTX 169 -FUBP1 2953 -FUBP3 1614 -FUCA1 469 -FUCA2 1218 -FUK 843 -FUNDC1 670 -FUNDC2 1580 -FUNDC2P2 5 -FUOM 39 -FURIN 4339 -FUS 5214 -FUT1 84 -FUT10 349 -FUT11 460 -FUT2 72 -FUT3 15 -FUT4 212 -FUT5 2 -FUT6 0 -FUT7 18 -FUT8 910 -FUT8-AS1 3 -FUT9 1894 -FUZ 858 -FXN 493 -FXR1 7599 -FXR2 5018 -FXYD1 3424 -FXYD2 1 -FXYD3 61 -FXYD4 0 -FXYD5 1177 -FXYD6 8765 -FXYD6-FXYD2 0 -FXYD7 1337 -FYB 1364 -FYCO1 1925 -FYN 7453 -FYTTD1 2770 -FZD1 847 -FZD10 30 -FZD10-AS1 79 -FZD2 188 -FZD3 3830 -FZD4 782 -FZD5 1401 -FZD6 602 -FZD7 932 -FZD8 519 -FZD9 270 -FZR1 2392 -G0S2 502 -G2E3 460 -G3BP1 2934 -G3BP2 4783 -G6PC 2 -G6PC2 0 -G6PC3 2196 -G6PD 1829 -GAA 3526 -GAB1 2536 -GAB2 4262 -GAB3 215 -GAB4 0 -GABARAP 7891 -GABARAPL1 7124 -GABARAPL2 4940 -GABARAPL3 52 -GABBR1 62 -GABBR2 2585 -GABPA 644 -GABPB1 450 -GABPB1-AS1 651 -GABPB2 440 -GABRA1 353 -GABRA2 477 -GABRA3 1060 -GABRA4 340 -GABRA5 1088 -GABRA6 0 -GABRB1 1082 -GABRB2 859 -GABRB3 2512 -GABRD 177 -GABRE 5870 -GABRG1 3837 -GABRG2 2225 -GABRG3 225 -GABRG3-AS1 3 -GABRP 2 -GABRQ 1166 -GABRR1 6 -GABRR2 77 -GABRR3 2 -GACAT1 0 -GACAT2 3 -GACAT3 1 -GAD1 4072 -GAD2 1418 -GADD45A 666 -GADD45B 4186 -GADD45G 564 -GADD45GIP1 2089 -GADL1 22 -GAGE1 7 -GAGE10 10 -GAGE12B 0 -GAGE12C 0 -GAGE12D 0 -GAGE12E 0 -GAGE12F 0 -GAGE12G 0 -GAGE12H 0 -GAGE12I 0 -GAGE12J 0 -GAGE13 0 -GAGE2A 0 -GAGE2B 0 -GAGE2C 0 -GAGE2D 0 -GAGE2E 0 -GAGE4 0 -GAGE5 0 -GAGE6 0 -GAGE7 0 -GAGE8 0 -GAK 4129 -GAL 10274 -GAL3ST1 203 -GAL3ST2 1 -GAL3ST3 265 -GAL3ST4 515 -GALC 1158 -GALE 249 -GALK1 201 -GALK2 430 -GALM 412 -GALNS 1355 -GALNT1 1861 -GALNT10 3308 -GALNT11 1425 -GALNT12 141 -GALNT13 1310 -GALNT14 105 -GALNT15 5435 -GALNT16 3864 -GALNT18 737 -GALNT2 2887 -GALNT3 520 -GALNT4 11 -GALNT5 24 -GALNT6 81 -GALNT7 748 -GALNT8 10 -GALNT9 692 -GALNTL5 0 -GALNTL6 30 -GALP 12 -GALR1 35 -GALR2 31 -GALR3 13 -GALT 751 -GAMT 1509 -GAN 276 -GANAB 6761 -GANC 627 -GAP43 10794 -GAPDH 56989 -GAPDHS 16 -GAPLINC 2 -GAPT 105 -GAPVD1 1938 -GAR1 420 -GAREM 2505 -GAREML 1625 -GARNL3 748 -GARS 3426 -GART 617 -GAS1 447 -GAS2 109 -GAS2L1 2980 -GAS2L1P2 66 -GAS2L2 147 -GAS2L3 57 -GAS5 1048 -GAS5-AS1 46 -GAS6 4617 -GAS6-AS1 45 -GAS6-AS2 118 -GAS7 3937 -GAS8 993 -GAS8-AS1 12 -GAST 18 -GATA1 4 -GATA2 381 -GATA2-AS1 183 -GATA3 42 -GATA3-AS1 0 -GATA4 11 -GATA5 16 -GATA6 26 -GATA6-AS1 3 -GATAD1 2303 -GATAD2A 3243 -GATAD2B 22 -GATB 727 -GATC 2004 -GATM 4514 -GATS 3876 -GATSL2 4886 -GATSL3 343 -GBA 4 -GBA2 4157 -GBA3 0 -GBAP1 264 -GBAS 1599 -GBAT2 18 -GBE1 781 -GBF1 3246 -GBGT1 485 -GBP1 1290 -GBP1P1 174 -GBP2 2204 -GBP3 1263 -GBP4 2313 -GBP5 229 -GBP6 27 -GBP7 8 -GBX1 2 -GBX2 146 -GC 0 -GCA 412 -GCAT 565 -GCC1 886 -GCC2 2549 -GCDH 540 -GCFC2 854 -GCG 2 -GCGR 10 -GCH1 674 -GCHFR 191 -GCK 401 -GCKR 51 -GCLC 1112 -GCLM 820 -GCM1 3 -GCM2 8 -GCN1 3028 -GCNT1 139 -GCNT2 166 -GCNT3 9 -GCNT4 28 -GCNT7 9 -GCOM1 0 -GCSAM 7 -GCSAML 2 -GCSAML-AS1 0 -GCSH 170 -GCSHP3 255 -GDA 1178 -GDAP1 1651 -GDAP1L1 498 -GDAP2 575 -GDE1 1807 -GDF1 0 -GDF10 328 -GDF11 3237 -GDF15 106 -GDF2 0 -GDF3 1 -GDF5 69 -GDF6 37 -GDF7 6 -GDF9 91 -GDI1 23448 -GDI2 3783 -GDNF 69 -GDNF-AS1 29 -GDPD1 652 -GDPD2 353 -GDPD3 323 -GDPD4 36 -GDPD5 432 -GDPGP1 124 -GEM 2101 -GEMIN2 169 -GEMIN4 440 -GEMIN5 692 -GEMIN6 180 -GEMIN7 327 -GEMIN8 650 -GEMIN8P4 105 -GEN1 155 -GET4 1857 -GFAP 910979 -GFER 1181 -GFI1 7 -GFI1B 1 -GFM1 1001 -GFM2 1257 -GFOD1 1079 -GFOD2 1697 -GFPT1 3037 -GFPT2 1750 -GFRA1 2703 -GFRA2 490 -GFRA3 15 -GFRA4 1 -GFRAL 4 -GFY 0 -GGA1 2670 -GGA2 3133 -GGA3 1831 -GGACT 48 -GGCT 946 -GGCX 1546 -GGH 469 -GGN 203 -GGNBP1 0 -GGNBP2 1 -GGPS1 1308 -GGT1 186 -GGT3P 55 -GGT5 1609 -GGT6 0 -GGT7 2616 -GGT8P 3 -GGTA1P 242 -GGTLC1 2 -GGTLC2 0 -GH1 0 -GH2 0 -GHDC 1093 -GHET1 29 -GHITM 5349 -GHR 601 -GHRH 1219 -GHRHR 12 -GHRL 8 -GHRLOS 61 -GHSR 184 -GID4 783 -GID8 1881 -GIF 0 -GIGYF1 4394 -GIGYF2 3502 -GIMAP1 312 -GIMAP1-GIMAP5 0 -GIMAP2 216 -GIMAP4 779 -GIMAP5 3 -GIMAP6 693 -GIMAP7 319 -GIMAP8 653 -GIMD1 0 -GIN1 413 -GINM1 781 -GINS1 35 -GINS2 34 -GINS3 135 -GINS4 39 -GIP 0 -GIPC1 2347 -GIPC2 51 -GIPC3 221 -GIPR 125 -GIT1 5817 -GIT2 2383 -GJA1 18972 -GJA10 0 -GJA3 4 -GJA4 165 -GJA5 134 -GJA8 2 -GJA9 0 -GJA9-MYCBP 8 -GJB1 135 -GJB2 133 -GJB3 10 -GJB4 2 -GJB5 3 -GJB6 557 -GJB7 5 -GJC1 343 -GJC2 572 -GJC3 14 -GJD2 5 -GJD3 56 -GJD4 12 -GK 101 -GK2 1 -GK3P 3 -GK5 1136 -GKAP1 1695 -GKN1 1 -GKN2 0 -GLA 206 -GLB1 944 -GLB1L 358 -GLB1L2 419 -GLB1L3 41 -GLCCI1 1170 -GLCE 503 -GLDC 272 -GLDN 152 -GLE1 720 -GLG1 7881 -GLI1 109 -GLI2 245 -GLI3 603 -GLI4 454 -GLIDR 32 -GLIPR1 285 -GLIPR1L1 6 -GLIPR1L2 248 -GLIPR2 267 -GLIS1 90 -GLIS2 42 -GLIS2-AS1 6 -GLIS3 1791 -GLIS3-AS1 7 -GLMN 126 -GLMP 613 -GLO1 3006 -GLOD4 1533 -GLOD5 0 -GLP1R 104 -GLP2R 90 -GLRA1 81 -GLRA2 1371 -GLRA3 97 -GLRA4 8 -GLRB 916 -GLRX 496 -GLRX2 242 -GLRX3 569 -GLRX5 1130 -GLS 4829 -GLS2 687 -GLT1D1 671 -GLT6D1 0 -GLT8D1 1074 -GLT8D2 156 -GLTP 1344 -GLTPD2 41 -GLTSCR1 1601 -GLTSCR1L 1530 -GLTSCR2 4502 -GLUD1 6578 -GLUD1P3 284 -GLUD1P7 59 -GLUD2 148 -GLUL 35514 -GLYAT 2 -GLYATL1 3 -GLYATL2 16 -GLYATL3 0 -GLYCAM1 0 -GLYCTK 97 -GLYCTK-AS1 25 -GLYR1 4422 -GM140 0 -GM2A 1595 -GMCL1 244 -GMCL1P1 3 -GMDS 325 -GMDS-AS1 81 -GMEB1 297 -GMEB2 928 -GMFB 4612 -GMFG 150 -GMIP 457 -GML 0 -GMNC 176 -GMNN 805 -GMPPA 622 -GMPPB 500 -GMPR 1995 -GMPR2 1491 -GMPS 432 -GNA11 5362 -GNA12 4942 -GNA13 3397 -GNA14 170 -GNA14-AS1 2 -GNA15 301 -GNAI1 1590 -GNAI2 17203 -GNAI3 1425 -GNAL 1717 -GNAO1 14309 -GNAQ 5458 -GNAS 145273 -GNAS-AS1 37 -GNAT1 1 -GNAT2 6 -GNAT3 3 -GNAZ 2340 -GNB1 14815 -GNB1L 158 -GNB2 7889 -GNB2L1 10709 -GNB3 486 -GNB4 1075 -GNB5 1607 -GNE 1410 -GNG10 84 -GNG11 659 -GNG12 2169 -GNG12-AS1 32 -GNG13 7 -GNG2 4033 -GNG3 2143 -GNG4 2422 -GNG5 1570 -GNG7 4499 -GNG8 31 -GNGT1 1 -GNGT2 24 -GNL1 1 -GNL2 978 -GNL3 1003 -GNL3L 2232 -GNLY 178 -GNMT 117 -GNPAT 1409 -GNPDA1 1508 -GNPDA2 451 -GNPNAT1 856 -GNPTAB 1606 -GNPTG 3243 -GNRH1 476 -GNRH2 8 -GNRHR 56 -GNRHR2 16 -GNS 3551 -GOLGA1 969 -GOLGA2 5405 -GOLGA2P10 46 -GOLGA2P2Y 0 -GOLGA2P3Y 0 -GOLGA2P5 673 -GOLGA2P6 1 -GOLGA2P7 23 -GOLGA2P9 1 -GOLGA3 7086 -GOLGA4 6701 -GOLGA5 1175 -GOLGA6A 0 -GOLGA6B 1 -GOLGA6C 0 -GOLGA6D 0 -GOLGA6L1 0 -GOLGA6L10 25 -GOLGA6L17P 20 -GOLGA6L2 0 -GOLGA6L22 0 -GOLGA6L3 1 -GOLGA6L4 0 -GOLGA6L5P 39 -GOLGA6L6 0 -GOLGA6L7P 1 -GOLGA6L9 6 -GOLGA7 1848 -GOLGA7B 2087 -GOLGA8A 1192 -GOLGA8B 497 -GOLGA8CP 0 -GOLGA8DP 0 -GOLGA8EP 0 -GOLGA8F 0 -GOLGA8G 0 -GOLGA8H 0 -GOLGA8IP 0 -GOLGA8J 3 -GOLGA8K 0 -GOLGA8M 0 -GOLGA8N 0 -GOLGA8O 5 -GOLGA8R 0 -GOLGA8S 20 -GOLGA8T 2 -GOLGB1 6515 -GOLIM4 4689 -GOLM1 10723 -GOLPH3 2648 -GOLPH3L 1932 -GOLT1A 134 -GOLT1B 877 -GON4L 1081 -GOPC 1888 -GORAB 401 -GORASP1 2332 -GORASP2 2584 -GOSR1 1657 -GOSR2 1634 -GOT1 2168 -GOT1L1 1 -GOT2 3266 -GP1BA 108 -GP1BB 0 -GP2 2 -GP5 6 -GP6 0 -GP9 3 -GPA33 6 -GPAA1 2453 -GPALPP1 408 -GPAM 651 -GPANK1 0 -GPAT2 83 -GPAT3 129 -GPAT4 2800 -GPATCH1 507 -GPATCH11 1245 -GPATCH2 605 -GPATCH2L 1701 -GPATCH3 297 -GPATCH4 1400 -GPATCH8 3904 -GPBAR1 16 -GPBP1 6257 -GPBP1L1 2816 -GPC1 3617 -GPC2 87 -GPC3 799 -GPC4 1048 -GPC5 218 -GPC5-AS1 3 -GPC5-AS2 2 -GPC6 745 -GPC6-AS1 1 -GPC6-AS2 6 -GPCPD1 628 -GPD1 188 -GPD1L 1239 -GPD2 1908 -GPER1 548 -GPHA2 12 -GPHB5 0 -GPHN 730 -GPI 7910 -GPIHBP1 282 -GPKOW 1146 -GPLD1 570 -GPM6A 8714 -GPM6B 20423 -GPN1 1155 -GPN2 538 -GPN3 405 -GPNMB 1449 -GPR1 18 -GPR1-AS 1 -GPR101 126 -GPR107 3511 -GPR108 1933 -GPR119 0 -GPR12 135 -GPR132 82 -GPR135 159 -GPR137 2321 -GPR137B 1076 -GPR137C 533 -GPR139 5 -GPR141 6 -GPR142 0 -GPR143 263 -GPR146 506 -GPR148 9 -GPR149 34 -GPR15 1 -GPR150 8 -GPR151 3 -GPR152 2 -GPR153 554 -GPR155 1862 -GPR156 33 -GPR157 10 -GPR158 1068 -GPR158-AS1 24 -GPR160 48 -GPR161 566 -GPR162 4290 -GPR17 527 -GPR171 14 -GPR173 1804 -GPR174 6 -GPR176 982 -GPR179 2 -GPR18 4 -GPR180 1019 -GPR182 4 -GPR183 60 -GPR19 660 -GPR20 0 -GPR21 5 -GPR22 80 -GPR25 1 -GPR26 350 -GPR27 322 -GPR3 319 -GPR31 0 -GPR32 0 -GPR33 0 -GPR34 343 -GPR35 360 -GPR37 636 -GPR37L1 2961 -GPR39 13 -GPR4 1252 -GPR45 43 -GPR50 172 -GPR52 7 -GPR55 25 -GPR6 404 -GPR61 86 -GPR62 100 -GPR63 110 -GPR65 132 -GPR68 246 -GPR75 759 -GPR75-ASB3 0 -GPR78 7 -GPR82 11 -GPR83 300 -GPR84 51 -GPR85 549 -GPR87 10 -GPR88 331 -GPR89A 474 -GPR89B 204 -GPRASP1 5079 -GPRASP2 39 -GPRC5A 53 -GPRC5B 10751 -GPRC5C 490 -GPRC5D 6 -GPRC6A 0 -GPRIN1 1847 -GPRIN2 134 -GPRIN3 352 -GPS1 2984 -GPS2 2488 -GPSM1 2694 -GPSM2 436 -GPSM3 1 -GPT 339 -GPT2 3561 -GPX1 2403 -GPX2 30 -GPX3 24524 -GPX4 8224 -GPX5 0 -GPX6 0 -GPX7 131 -GPX8 740 -GRAMD1A 2691 -GRAMD1B 2280 -GRAMD1C 530 -GRAMD2 423 -GRAMD3 3193 -GRAMD4 1584 -GRAP 182 -GRAP2 52 -GRAPL 0 -GRASP 920 -GRB10 3890 -GRB14 66 -GRB2 4657 -GRB7 36 -GREB1 1704 -GREB1L 240 -GREM1 3 -GREM2 305 -GRHL1 191 -GRHL2 29 -GRHL3 24 -GRHPR 1914 -GRIA1 6277 -GRIA2 3368 -GRIA3 1298 -GRIA4 2146 -GRID1 1509 -GRID1-AS1 16 -GRID2 430 -GRID2IP 26 -GRIFIN 1 -GRIK1 672 -GRIK1-AS1 17 -GRIK1-AS2 10 -GRIK2 1274 -GRIK3 4239 -GRIK4 989 -GRIK5 3383 -GRIN1 10554 -GRIN2A 898 -GRIN2B 156 -GRIN2C 712 -GRIN2D 650 -GRIN3A 375 -GRIN3B 80 -GRINA 10444 -GRIP1 307 -GRIP2 725 -GRIPAP1 3226 -GRK1 3 -GRK4 407 -GRK5 898 -GRK6 812 -GRK7 20 -GRM1 182 -GRM2 117 -GRM3 301 -GRM4 275 -GRM5 115 -GRM5-AS1 4 -GRM6 240 -GRM7 489 -GRM7-AS1 0 -GRM7-AS2 0 -GRM7-AS3 0 -GRM8 107 -GRN 4294 -GRP 127 -GRPEL1 818 -GRPEL2 586 -GRPR 5 -GRSF1 3854 -GRTP1 223 -GRTP1-AS1 31 -GRWD1 791 -GRXCR1 0 -GRXCR2 0 -GS1-124K5.11 899 -GS1-24F4.2 0 -GS1-259H13.2 49 -GS1-279B7.1 0 -GS1-594A7.3 0 -GS1-600G8.3 0 -GSAP 600 -GSC 5 -GSC2 0 -GSDMA 1 -GSDMB 516 -GSDMC 15 -GSDMD 0 -GSE1 2061 -GSG1 16 -GSG1L 695 -GSG1L2 0 -GSG2 8 -GSK3A 4352 -GSK3B 2382 -GSKIP 603 -GSN 32376 -GSN-AS1 132 -GSPT1 2880 -GSPT2 918 -GSR 1041 -GSS 790 -GSTA1 34 -GSTA2 2 -GSTA3 0 -GSTA4 1245 -GSTA5 0 -GSTA7P 0 -GSTCD 245 -GSTK1 1736 -GSTM1 6 -GSTM2 977 -GSTM2P1 18 -GSTM3 3877 -GSTM4 584 -GSTM5 436 -GSTO1 1164 -GSTO2 209 -GSTP1 6657 -GSTT1 1140 -GSTT2 2 -GSTT2B 0 -GSTTP1 0 -GSTTP2 0 -GSTZ1 194 -GSX1 30 -GSX2 3 -GTDC1 625 -GTF2A1 1446 -GTF2A1L 0 -GTF2A2 1051 -GTF2B 723 -GTF2E1 306 -GTF2E2 933 -GTF2F1 3977 -GTF2F2 824 -GTF2H1 875 -GTF2H2 0 -GTF2H2B 34 -GTF2H2C 0 -GTF2H2C_2 3 -GTF2H3 490 -GTF2H4 0 -GTF2H5 2116 -GTF2I 1636 -GTF2IP1 1684 -GTF2IP20 223 -GTF2IP4 0 -GTF2IRD1 1069 -GTF2IRD1P1 6 -GTF2IRD2 111 -GTF2IRD2B 79 -GTF3A 1764 -GTF3C1 4042 -GTF3C2 922 -GTF3C2-AS1 5 -GTF3C3 1355 -GTF3C4 351 -GTF3C5 1372 -GTF3C6 1084 -GTPBP1 2408 -GTPBP10 1090 -GTPBP2 1254 -GTPBP3 507 -GTPBP4 886 -GTPBP6 0 -GTPBP8 156 -GTSCR1 2 -GTSE1 17 -GTSE1-AS1 38 -GTSF1 7 -GTSF1L 0 -GUCA1A 228 -GUCA1B 360 -GUCA1C 0 -GUCA2A 1 -GUCA2B 0 -GUCD1 938 -GUCY1A2 1334 -GUCY1A3 1293 -GUCY1B2 0 -GUCY1B3 1703 -GUCY2C 6 -GUCY2D 8 -GUCY2EP 0 -GUCY2F 1 -GUCY2GP 0 -GUF1 774 -GUK1 4717 -GULP1 304 -GUSB 736 -GUSBP1 303 -GUSBP10 0 -GUSBP11 1317 -GUSBP2 5 -GUSBP3 1 -GUSBP4 308 -GUSBP5 12 -GUSBP9 0 -GVINP1 201 -GXYLT1 881 -GXYLT1P3 10 -GXYLT2 94 -GYG1 1828 -GYG2 938 -GYG2P1 0 -GYLTL1B 10 -GYPA 1 -GYPB 0 -GYPC 942 -GYPE 4 -GYS1 1819 -GYS2 47 -GZF1 985 -GZMA 12 -GZMB 44 -GZMH 3 -GZMK 21 -GZMM 82 -H19 6 -H1F0 3927 -H1FNT 1 -H1FOO 0 -H1FX 5901 -H1FX-AS1 336 -H2AFB1 0 -H2AFB2 2 -H2AFB3 0 -H2AFJ 598 -H2AFV 3772 -H2AFX 2887 -H2AFY 3568 -H2AFY2 452 -H2AFZ 1927 -H2BFM 1 -H2BFWT 0 -H2BFXP 0 -H3F3A 0 -H3F3AP4 54 -H3F3B 5297 -H3F3C 123 -H6PD 2487 -HAAO 104 -HABP2 1 -HABP4 4367 -HACD1 141 -HACD2 317 -HACD3 6537 -HACD4 225 -HACE1 596 -HACL1 221 -HADH 1146 -HADHA 4019 -HADHB 4001 -HAGH 2683 -HAGHL 764 -HAGLR 125 -HAGLROS 2 -HAL 5 -HAMP 91 -HAND1 8 -HAND2 16 -HAND2-AS1 1 -HAO1 4 -HAO2 1 -HAO2-IT1 0 -HAP1 4505 -HAPLN1 29 -HAPLN2 1787 -HAPLN3 414 -HAPLN4 1415 -HAR1A 134 -HAR1B 27 -HARBI1 181 -HARS 3632 -HARS2 718 -HAS1 130 -HAS2 99 -HAS2-AS1 58 -HAS3 150 -HAT1 734 -HAUS1 152 -HAUS2 862 -HAUS3 308 -HAUS4 419 -HAUS5 661 -HAUS6 480 -HAUS7 519 -HAUS8 89 -HAVCR1 6 -HAVCR1P1 33 -HAVCR2 383 -HAX1 2479 -HBA1 326 -HBA2 387 -HBB 2246 -HBBP1 0 -HBD 3 -HBE1 3 -HBEGF 1274 -HBG1 0 -HBG2 1 -HBM 0 -HBP1 1012 -HBQ1 31 -HBS1L 1552 -HBZ 2 -HCAR1 9 -HCAR2 11 -HCAR3 2 -HCCAT5 9 -HCCS 506 -HCFC1 4824 -HCFC1-AS1 4 -HCFC1R1 2256 -HCFC2 492 -HCG11 687 -HCG14 0 -HCG17 2 -HCG18 52 -HCG2040054 4 -HCG22 10 -HCG23 31 -HCG25 8 -HCG26 0 -HCG27 0 -HCG4 0 -HCG4B 4 -HCG8 0 -HCG9 0 -HCK 233 -HCLS1 1098 -HCN1 516 -HCN2 3808 -HCN3 32 -HCN4 279 -HCP5 0 -HCRT 308 -HCRTR1 39 -HCRTR2 17 -HCST 114 -HDAC1 2040 -HDAC10 1599 -HDAC11 2277 -HDAC11-AS1 0 -HDAC2 2256 -HDAC3 764 -HDAC4 2620 -HDAC5 6200 -HDAC6 3538 -HDAC7 2713 -HDAC8 750 -HDAC9 607 -HDC 2550 -HDDC2 2700 -HDDC3 232 -HDGF 6083 -HDGFL1 1 -HDGFRP2 2368 -HDGFRP3 3362 -HDHD1 479 -HDHD2 1984 -HDHD3 789 -HDLBP 12611 -HDX 216 -HEATR1 555 -HEATR3 190 -HEATR4 81 -HEATR5A 1776 -HEATR5B 1388 -HEATR6 784 -HEATR9 0 -HEBP1 1290 -HEBP2 1327 -HECA 1833 -HECTD1 5407 -HECTD2 583 -HECTD2-AS1 4 -HECTD3 1403 -HECTD4 6810 -HECW1 155 -HECW2 282 -HEG1 2645 -HEIH 1029 -HELB 132 -HELLS 51 -HELQ 370 -HELT 0 -HELZ 2891 -HELZ2 1420 -HEMGN 0 -HEMK1 879 -HENMT1 354 -HEPACAM 1735 -HEPACAM2 9 -HEPH 1209 -HEPHL1 5 -HEPN1 0 -HERC1 3787 -HERC2 814 -HERC2P10 5 -HERC2P2 1853 -HERC2P3 4324 -HERC2P4 13 -HERC2P7 34 -HERC2P9 243 -HERC3 1542 -HERC4 2964 -HERC5 466 -HERC6 612 -HERPUD1 7759 -HERPUD2 868 -HES1 1178 -HES2 1 -HES3 0 -HES4 592 -HES5 0 -HES6 588 -HES7 44 -HESX1 19 -HEXA 1542 -HEXA-AS1 33 -HEXB 2006 -HEXDC 792 -HEXIM1 4254 -HEXIM2 322 -HEY1 954 -HEY2 872 -HEYL 515 -HFE 120 -HFE2 1 -HFM1 92 -HGC6.3 4 -HGD 36 -HGF 150 -HGFAC 168 -HGH1 371 -HGS 4469 -HGSNAT 1782 -HHAT 143 -HHATL 577 -HHEX 260 -HHIP 69 -HHIP-AS1 82 -HHIPL1 566 -HHIPL2 19 -HHLA1 0 -HHLA2 6 -HHLA3 473 -HIAT1 1386 -HIATL1 1119 -HIATL2 89 -HIBADH 967 -HIBCH 1439 -HIC1 888 -HIC2 702 -HID1 2797 -HID1-AS1 7 -HIF1A 2605 -HIF1A-AS1 5 -HIF1A-AS2 9 -HIF1AN 1877 -HIF3A 4927 -HIGD1A 2528 -HIGD1B 119 -HIGD1C 11 -HIGD2A 1531 -HIGD2B 0 -HILPDA 353 -HILS1 52 -HINFP 973 -HINT1 3479 -HINT2 465 -HINT3 1380 -HIP1 3545 -HIP1R 4806 -HIPK1 7281 -HIPK1-AS1 34 -HIPK2 32970 -HIPK3 5459 -HIPK4 77 -HIRA 1774 -HIRIP3 1698 -HIST1H1A 0 -HIST1H1B 1 -HIST1H1C 704 -HIST1H1D 1 -HIST1H1E 26 -HIST1H1T 10 -HIST1H2AA 0 -HIST1H2AB 0 -HIST1H2AC 263 -HIST1H2AD 0 -HIST1H2AE 14 -HIST1H2AG 10 -HIST1H2AH 2 -HIST1H2AI 0 -HIST1H2AJ 0 -HIST1H2AK 20 -HIST1H2AL 0 -HIST1H2AM 1 -HIST1H2APS1 0 -HIST1H2BA 0 -HIST1H2BB 1 -HIST1H2BC 36 -HIST1H2BD 383 -HIST1H2BE 11 -HIST1H2BF 0 -HIST1H2BG 4 -HIST1H2BH 1 -HIST1H2BI 0 -HIST1H2BJ 10 -HIST1H2BK 316 -HIST1H2BL 1 -HIST1H2BM 1 -HIST1H2BN 3 -HIST1H2BO 1 -HIST1H3A 0 -HIST1H3B 0 -HIST1H3C 0 -HIST1H3D 17 -HIST1H3E 6 -HIST1H3F 0 -HIST1H3G 0 -HIST1H3H 2 -HIST1H3I 0 -HIST1H3J 0 -HIST1H4A 1 -HIST1H4B 1 -HIST1H4C 34 -HIST1H4D 14 -HIST1H4E 26 -HIST1H4F 0 -HIST1H4G 0 -HIST1H4H 73 -HIST1H4I 5 -HIST1H4J 0 -HIST1H4K 9 -HIST1H4L 0 -HIST2H2AA3 0 -HIST2H2AA4 0 -HIST2H2AB 1 -HIST2H2AC 7 -HIST2H2BA 10 -HIST2H2BC 37 -HIST2H2BE 1264 -HIST2H2BF 24 -HIST2H3A 0 -HIST2H3C 0 -HIST2H3D 2 -HIST2H4A 0 -HIST2H4B 0 -HIST3H2A 88 -HIST3H2BB 4 -HIST3H3 4 -HIST4H4 23 -HIVEP1 1281 -HIVEP2 2783 -HIVEP3 1211 -HJURP 5 -HK1 6320 -HK2 299 -HK3 74 -HKDC1 50 -HKR1 1260 -HLA-A 35 -HLA-B 272 -HLA-C 17 -HLA-DMA 1 -HLA-DMB 0 -HLA-DOA 20 -HLA-DOB 2 -HLA-DPA1 0 -HLA-DPB1 0 -HLA-DPB2 1 -HLA-DQA1 290 -HLA-DQA2 0 -HLA-DQB1 608 -HLA-DQB2 0 -HLA-DRA 550 -HLA-DRB1 658 -HLA-DRB3 260 -HLA-DRB4 0 -HLA-DRB5 11 -HLA-DRB6 136 -HLA-E 13 -HLA-F 1 -HLA-F-AS1 5 -HLA-G 0 -HLA-H 231 -HLA-J 221 -HLA-L 7 -HLCS 762 -HLF 940 -HLTF 1443 -HLTF-AS1 0 -HLX 165 -HLX-AS1 1 -HM13 3143 -HM13-AS1 45 -HMBOX1 1914 -HMBS 263 -HMCES 1176 -HMCN1 1383 -HMCN2 181 -HMG20A 964 -HMG20B 1806 -HMGA1 1433 -HMGA1P7 12 -HMGA2 182 -HMGB1 1653 -HMGB2 973 -HMGB3 336 -HMGB3P1 1 -HMGB4 0 -HMGCL 395 -HMGCLL1 361 -HMGCR 1703 -HMGCS1 2221 -HMGCS2 4 -HMGN1 1142 -HMGN2 500 -HMGN2P46 3 -HMGN3 1742 -HMGN3-AS1 69 -HMGN4 1326 -HMGN5 1993 -HMGXB3 1423 -HMGXB4 669 -HMHA1 1568 -HMHB1 0 -HMMR 9 -HMMR-AS1 0 -HMOX1 3273 -HMOX2 0 -HMP19 8099 -HMSD 38 -HMX1 94 -HMX2 47 -HMX3 123 -HN1 1846 -HN1L 1028 -HNCAT21 0 -HNF1A 92 -HNF1A-AS1 2 -HNF1B 0 -HNF4A 2 -HNF4A-AS1 0 -HNF4G 19 -HNMT 1388 -HNRNPA0 4257 -HNRNPA1 1590 -HNRNPA1L2 245 -HNRNPA1P10 81 -HNRNPA1P33 0 -HNRNPA2B1 25918 -HNRNPA3 5733 -HNRNPA3P1 18 -HNRNPAB 3129 -HNRNPC 6635 -HNRNPCL1 11 -HNRNPCL2 0 -HNRNPCL3 0 -HNRNPCL4 0 -HNRNPD 4513 -HNRNPDL 5129 -HNRNPF 5285 -HNRNPH1 6978 -HNRNPH2 34 -HNRNPH3 9459 -HNRNPK 9510 -HNRNPKP3 2 -HNRNPL 3746 -HNRNPLL 988 -HNRNPM 5634 -HNRNPR 3247 -HNRNPU 13832 -HNRNPU-AS1 3460 -HNRNPUL1 8222 -HNRNPUL2 2846 -HNRNPUL2-BSCL2 0 -HOGA1 211 -HOMER1 845 -HOMER2 340 -HOMER3 1935 -HOMEZ 301 -HOOK1 436 -HOOK2 1481 -HOOK3 4204 -HOPX 1153 -HORMAD1 15 -HORMAD2 8 -HORMAD2-AS1 19 -HOTAIR 1 -HOTAIRM1 23 -HOTS 1 -HOTTIP 0 -HOXA-AS2 0 -HOXA-AS3 0 -HOXA1 6 -HOXA10 3 -HOXA10-AS 0 -HOXA10-HOXA9 0 -HOXA11 2 -HOXA11-AS 0 -HOXA13 1 -HOXA2 0 -HOXA3 2 -HOXA4 0 -HOXA5 0 -HOXA6 0 -HOXA7 0 -HOXA9 1 -HOXB-AS1 1 -HOXB-AS3 0 -HOXB1 0 -HOXB13 2 -HOXB2 61 -HOXB3 50 -HOXB4 13 -HOXB5 4 -HOXB6 3 -HOXB7 13 -HOXB8 1 -HOXB9 1 -HOXC-AS1 0 -HOXC-AS2 0 -HOXC-AS3 1 -HOXC10 8 -HOXC11 0 -HOXC12 0 -HOXC13 0 -HOXC13-AS 0 -HOXC4 23 -HOXC5 0 -HOXC6 3 -HOXC8 1 -HOXC9 2 -HOXD-AS2 1 -HOXD1 12 -HOXD10 0 -HOXD11 0 -HOXD12 0 -HOXD13 1 -HOXD3 0 -HOXD4 1 -HOXD8 1 -HOXD9 0 -HP 36 -HP09025 4 -HP09053 9 -HP1BP3 8929 -HPCA 869 -HPCAL1 4224 -HPCAL4 3093 -HPD 175 -HPDL 41 -HPGD 115 -HPGDS 92 -HPN 61 -HPN-AS1 26 -HPR 170 -HPRT1 1357 -HPS1 1873 -HPS3 654 -HPS4 1546 -HPS5 1571 -HPS6 249 -HPSE 67 -HPSE2 1378 -HPVC1 0 -HPX 39 -HPYR1 15 -HR 598 -HRAS 0 -HRASLS 109 -HRASLS2 18 -HRASLS5 328 -HRAT13 35 -HRAT17 0 -HRAT5 38 -HRAT56 2 -HRAT92 147 -HRC 84 -HRCT1 54 -HRG 0 -HRH1 582 -HRH2 107 -HRH3 1594 -HRH4 39 -HRK 79 -HRNR 13 -HRSP12 1364 -HS1BP3 883 -HS1BP3-IT1 6 -HS2ST1 1509 -HS3ST1 555 -HS3ST2 201 -HS3ST3A1 104 -HS3ST3B1 183 -HS3ST4 761 -HS3ST5 79 -HS3ST6 0 -HS6ST1 2086 -HS6ST2 879 -HS6ST2-AS1 0 -HS6ST3 1061 -HSBP1 4732 -HSBP1L1 752 -HSCB 285 -HSD11B1 103 -HSD11B1L 1169 -HSD11B2 53 -HSD17B1 413 -HSD17B10 1235 -HSD17B11 1201 -HSD17B12 2441 -HSD17B13 58 -HSD17B14 1159 -HSD17B2 2 -HSD17B3 87 -HSD17B4 4883 -HSD17B6 211 -HSD17B7 595 -HSD17B7P2 280 -HSD17B8 0 -HSD3B1 0 -HSD3B2 0 -HSD3B7 491 -HSD3BP4 47 -HSD52 0 -HSDL1 1917 -HSDL2 2075 -HSF1 3453 -HSF2 587 -HSF2BP 19 -HSF4 2106 -HSF5 6 -HSFX1 0 -HSFX2 0 -HSFY1 0 -HSFY1P1 0 -HSFY2 0 -HSH2D 22 -HSP90AA1 285698 -HSP90AB1 69997 -HSP90AB4P 115 -HSP90B1 33833 -HSP90B2P 746 -HSPA12A 2500 -HSPA12B 296 -HSPA13 2217 -HSPA14 762 -HSPA1A 74 -HSPA1B 1525 -HSPA1L 16 -HSPA2 3173 -HSPA4 8581 -HSPA4L 6301 -HSPA5 33850 -HSPA6 29120 -HSPA7 2702 -HSPA8 58842 -HSPA9 10187 -HSPB1 77243 -HSPB11 336 -HSPB2 415 -HSPB2-C11orf52 8 -HSPB3 88 -HSPB6 3440 -HSPB7 374 -HSPB8 11881 -HSPB9 36 -HSPBAP1 448 -HSPBP1 1710 -HSPD1 22925 -HSPE1 2920 -HSPE1-MOB4 11 -HSPG2 2878 -HSPH1 63696 -HTATIP2 1257 -HTATSF1 5429 -HTATSF1P2 745 -HTN1 4 -HTN3 3 -HTR1A 17 -HTR1B 27 -HTR1D 44 -HTR1E 32 -HTR1F 16 -HTR2A 408 -HTR2A-AS1 0 -HTR2B 12 -HTR2C 972 -HTR3A 1 -HTR3B 2 -HTR3C 1 -HTR3D 1 -HTR3E 14 -HTR4 28 -HTR5A 458 -HTR5A-AS1 96 -HTR6 36 -HTR7 76 -HTR7P1 100 -HTRA1 6888 -HTRA2 476 -HTRA3 103 -HTRA4 17 -HTT 3863 -HTT-AS 11 -HULC 3 -HUNK 1124 -HUS1 867 -HUS1B 5 -HUWE1 12907 -HVCN1 1466 -HYAL1 234 -HYAL2 968 -HYAL3 109 -HYAL4 0 -HYALP1 0 -HYDIN 1487 -HYDIN2 648 -HYI 0 -HYKK 48 -HYLS1 212 -HYMAI 13 -HYOU1 12239 -HYPK 24 -HYPM 1 -IAH1 711 -IAPP 1 -IARS 2924 -IARS2 1529 -IBA57 575 -IBA57-AS1 26 -IBSP 2 -IBTK 1139 -ICA1 290 -ICA1L 2215 -ICAM1 2255 -ICAM2 198 -ICAM3 182 -ICAM4 14 -ICAM5 253 -ICE1 1959 -ICE2 1655 -ICK 771 -ICMT 2392 -ICOS 1 -ICOSLG 49 -ICT1 365 -ID1 913 -ID2 991 -ID2-AS1 76 -ID3 5722 -ID4 6864 -IDE 790 -IDH1 985 -IDH1-AS1 19 -IDH2 1256 -IDH3A 2975 -IDH3B 1658 -IDH3G 1592 -IDI1 2256 -IDI2 106 -IDI2-AS1 107 -IDNK 646 -IDO1 9 -IDO2 0 -IDS 18089 -IDUA 938 -IER2 2213 -IER3 8 -IER3IP1 719 -IER5 7511 -IER5L 1598 -IFFO1 1104 -IFFO2 1665 -IFI16 1945 -IFI27 0 -IFI27L1 0 -IFI27L2 0 -IFI30 508 -IFI35 528 -IFI44 529 -IFI44L 2584 -IFI6 9471 -IFIH1 647 -IFIT1 1439 -IFIT1B 5 -IFIT2 595 -IFIT3 1213 -IFIT5 1000 -IFITM1 3101 -IFITM10 141 -IFITM2 2141 -IFITM3 9430 -IFITM4P 2 -IFITM5 5 -IFNA1 0 -IFNA10 0 -IFNA13 0 -IFNA14 0 -IFNA16 0 -IFNA17 0 -IFNA2 0 -IFNA21 1 -IFNA22P 2 -IFNA4 0 -IFNA5 0 -IFNA6 0 -IFNA7 0 -IFNA8 0 -IFNAR1 3181 -IFNAR2 1218 -IFNB1 0 -IFNE 6 -IFNG 3 -IFNG-AS1 1 -IFNGR1 2502 -IFNGR2 89 -IFNK 0 -IFNL1 0 -IFNL2 0 -IFNL3 0 -IFNL4 2 -IFNLR1 221 -IFNW1 2 -IFRD1 3313 -IFRD2 458 -IFT122 1043 -IFT140 3139 -IFT172 2075 -IFT20 465 -IFT22 953 -IFT27 878 -IFT43 647 -IFT46 1322 -IFT52 393 -IFT57 1730 -IFT74 708 -IFT74-AS1 0 -IFT80 1439 -IFT81 803 -IFT88 866 -IGBP1 1238 -IGBP1P1 49 -IGDCC3 145 -IGDCC4 661 -IGF1 49 -IGF1R 4026 -IGF2 130 -IGF2-AS 9 -IGF2BP1 0 -IGF2BP2 271 -IGF2BP2-AS1 1 -IGF2BP3 29 -IGF2R 3586 -IGFALS 39 -IGFBP1 4 -IGFBP2 1607 -IGFBP3 2586 -IGFBP4 1669 -IGFBP5 18573 -IGFBP6 8388 -IGFBP7 7393 -IGFBP7-AS1 70 -IGFBPL1 123 -IGFL1 2 -IGFL2 1 -IGFL3 1 -IGFL4 28 -IGFLR1 148 -IGFN1 135 -IGHMBP2 794 -IGIP 2424 -IGLL1 2 -IGLL3P 42 -IGLL5 230 -IGLON5 1141 -IGSF1 2743 -IGSF10 220 -IGSF11 1193 -IGSF11-AS1 2 -IGSF21 641 -IGSF22 167 -IGSF23 4 -IGSF3 411 -IGSF5 78 -IGSF6 99 -IGSF8 4290 -IGSF9 95 -IGSF9B 540 -IHH 23 -IK 2914 -IKBIP 225 -IKBKAP 2526 -IKBKB 1903 -IKBKE 100 -IKBKG 71 -IKZF1 441 -IKZF2 425 -IKZF3 169 -IKZF4 1199 -IKZF5 1420 -IL10 8 -IL10RA 552 -IL10RB 760 -IL10RB-AS1 63 -IL11 66 -IL11RA 733 -IL12A 60 -IL12A-AS1 4 -IL12B 0 -IL12RB1 35 -IL12RB2 37 -IL13 3 -IL13RA1 2201 -IL13RA2 888 -IL15 84 -IL15RA 219 -IL16 705 -IL17A 0 -IL17B 5 -IL17C 7 -IL17D 2683 -IL17F 0 -IL17RA 1924 -IL17RB 1295 -IL17RC 970 -IL17RD 1179 -IL17RE 124 -IL17REL 14 -IL18 293 -IL18BP 655 -IL18R1 295 -IL18RAP 12 -IL19 0 -IL1A 21 -IL1B 119 -IL1F10 0 -IL1R1 1595 -IL1R2 43 -IL1RAP 277 -IL1RAPL1 113 -IL1RAPL2 11 -IL1RL1 82 -IL1RL2 22 -IL1RN 6 -IL2 0 -IL20 1 -IL20RA 303 -IL20RB 73 -IL21 0 -IL21-AS1 1 -IL21R 47 -IL21R-AS1 136 -IL22 0 -IL22RA1 2 -IL22RA2 0 -IL23A 14 -IL23R 0 -IL24 2 -IL25 0 -IL26 0 -IL27 9 -IL27RA 283 -IL2RA 42 -IL2RB 31 -IL2RG 162 -IL3 0 -IL31 4 -IL31RA 4 -IL32 704 -IL33 587 -IL34 561 -IL36A 0 -IL36B 0 -IL36G 0 -IL36RN 0 -IL37 0 -IL3RA 17 -IL4 1 -IL4I1 23 -IL4R 1628 -IL5 1 -IL5RA 89 -IL6 825 -IL6R 745 -IL6ST 15389 -IL7 46 -IL7R 412 -IL9 5 -IL9R 0 -ILDR1 3 -ILDR2 1556 -ILF2 2534 -ILF3 7590 -ILF3-AS1 1013 -ILK 2991 -ILKAP 962 -ILVBL 1021 -IMMP1L 78 -IMMP2L 287 -IMMT 1545 -IMP3 1028 -IMP4 842 -IMPA1 907 -IMPA2 355 -IMPACT 1350 -IMPAD1 3050 -IMPDH1 974 -IMPDH2 1743 -IMPG1 28 -IMPG2 92 -INA 5515 -INADL 1288 -INAFM1 1045 -INAFM2 1081 -INCA1 135 -INCENP 465 -INE1 83 -INE2 0 -INF2 3878 -ING1 1066 -ING2 868 -ING3 341 -ING4 955 -ING5 1894 -INGX 0 -INHA 27 -INHBA 367 -INHBA-AS1 69 -INHBB 569 -INHBC 1 -INHBE 25 -INIP 358 -INMT 123 -INMT-FAM188B 2 -INO80 1058 -INO80B 106 -INO80B-WBP1 1 -INO80C 498 -INO80D 1585 -INO80E 1134 -INPP1 1404 -INPP4A 2165 -INPP4B 256 -INPP5A 1166 -INPP5B 1792 -INPP5D 1534 -INPP5E 1886 -INPP5F 8116 -INPP5J 328 -INPP5K 1199 -INPPL1 5707 -INS 3 -INS-IGF2 0 -INSC 7 -INSIG1 1762 -INSIG2 688 -INSL3 35 -INSL4 0 -INSL5 24 -INSL6 0 -INSM1 487 -INSM2 50 -INSR 3932 -INSRR 39 -INTS1 4646 -INTS10 1482 -INTS12 836 -INTS2 650 -INTS3 2 -INTS4 468 -INTS4P2 57 -INTS5 581 -INTS6 943 -INTS6-AS1 73 -INTS7 585 -INTS8 1200 -INTS9 483 -INTU 785 -INVS 558 -IP6K1 4091 -IP6K2 2787 -IP6K3 159 -IPCEF1 575 -IPMK 292 -IPO11 177 -IPO11-LRRC70 1 -IPO13 2266 -IPO4 488 -IPO5 3487 -IPO5P1 579 -IPO7 3903 -IPO8 1907 -IPO9 3860 -IPO9-AS1 10 -IPP 563 -IPPK 532 -IPW 3000 -IQCA1 2216 -IQCA1L 6 -IQCB1 617 -IQCC 191 -IQCD 153 -IQCE 4644 -IQCF1 4 -IQCF2 0 -IQCF3 0 -IQCF4 0 -IQCF5 0 -IQCF5-AS1 1 -IQCF6 0 -IQCG 1001 -IQCH 170 -IQCH-AS1 148 -IQCJ 17 -IQCJ-SCHIP1 0 -IQCJ-SCHIP1-AS1 1 -IQCK 6237 -IQGAP1 5204 -IQGAP2 333 -IQGAP3 27 -IQSEC1 5219 -IQSEC2 2945 -IQSEC3 1837 -IQUB 106 -IRAIN 63 -IRAK1 3059 -IRAK1BP1 235 -IRAK2 487 -IRAK3 664 -IRAK4 672 -IREB2 1235 -IRF1 2427 -IRF2 1472 -IRF2BP1 2232 -IRF2BP2 8662 -IRF2BPL 5150 -IRF3 1953 -IRF4 63 -IRF5 356 -IRF6 312 -IRF7 18 -IRF8 538 -IRF9 2740 -IRG1 1 -IRGC 11 -IRGM 1 -IRGQ 2941 -IRS1 1298 -IRS2 9559 -IRS4 391 -IRX1 550 -IRX2 448 -IRX3 1132 -IRX4 1 -IRX5 257 -IRX6 81 -ISCA1 1126 -ISCA2 465 -ISCU 5283 -ISG15 922 -ISG20 329 -ISG20L2 897 -ISL1 527 -ISL2 11 -ISLR 1398 -ISLR2 189 -ISM1 253 -ISM1-AS1 1 -ISM2 108 -ISOC1 1253 -ISOC2 797 -ISPD 153 -ISPD-AS1 2 -IST1 3679 -ISX 0 -ISY1 549 -ISY1-RAB43 0 -ISYNA1 2193 -ITCH 2037 -ITFG1 2268 -ITFG1-AS1 13 -ITFG2 631 -ITFG3 1514 -ITGA1 1119 -ITGA10 834 -ITGA11 203 -ITGA2 591 -ITGA2B 124 -ITGA3 3045 -ITGA4 124 -ITGA5 1587 -ITGA6 1851 -ITGA7 4034 -ITGA8 368 -ITGA9 292 -ITGA9-AS1 36 -ITGAD 1 -ITGAE 296 -ITGAL 301 -ITGAM 687 -ITGAV 4741 -ITGAX 781 -ITGB1 3464 -ITGB1BP1 1610 -ITGB1BP2 13 -ITGB2 1655 -ITGB2-AS1 72 -ITGB3 259 -ITGB3BP 132 -ITGB4 7241 -ITGB5 3049 -ITGB6 2 -ITGB7 121 -ITGB8 7645 -ITGBL1 1349 -ITIH1 2 -ITIH2 574 -ITIH3 87 -ITIH4 277 -ITIH4-AS1 0 -ITIH5 1932 -ITIH6 1 -ITK 42 -ITLN1 1 -ITLN2 0 -ITM2A 1564 -ITM2B 22469 -ITM2C 24276 -ITPA 418 -ITPK1 1 -ITPK1-AS1 0 -ITPKA 101 -ITPKB 11064 -ITPKB-IT1 6 -ITPKC 1827 -ITPR1 1914 -ITPR1-AS1 33 -ITPR2 2320 -ITPR3 1849 -ITPRIP 1522 -ITPRIPL1 24 -ITPRIPL2 1609 -ITSN1 6098 -ITSN2 3559 -IVD 2661 -IVL 0 -IVNS1ABP 3014 -IWS1 1582 -IYD 0 -IZUMO1 4 -IZUMO1R 4 -IZUMO2 6 -IZUMO3 0 -IZUMO4 373 -JADE1 4468 -JADE2 4709 -JADE3 476 -JAG1 2609 -JAG2 1817 -JAGN1 845 -JAK1 5407 -JAK2 685 -JAK3 1043 -JAKMIP1 2293 -JAKMIP2 2142 -JAKMIP2-AS1 29 -JAKMIP3 938 -JAM2 3006 -JAM3 4566 -JARID2 1441 -JARID2-AS1 3 -JAZF1 1688 -JAZF1-AS1 38 -JCHAIN 259 -JDP2 3854 -JHDM1D-AS1 75 -JKAMP 1861 -JMJD1C 3021 -JMJD1C-AS1 22 -JMJD4 169 -JMJD6 6517 -JMJD7 505 -JMJD7-PLA2G4B 0 -JMJD8 1555 -JMY 1972 -JOSD1 3060 -JOSD2 821 -JPH1 79 -JPH2 187 -JPH3 5386 -JPH4 7566 -JPX 178 -JRK 1386 -JRKL 592 -JRKL-AS1 0 -JSRP1 29 -JTB 3258 -JUN 17467 -JUNB 6442 -JUND 18418 -JUP 2144 -KAAG1 5 -KALRN 1256 -KANK1 2800 -KANK2 5030 -KANK3 501 -KANK4 163 -KANSL1 66 -KANSL1-AS1 7 -KANSL1L 1862 -KANSL2 628 -KANSL3 2664 -KANTR 149 -KARS 2738 -KAT2A 7354 -KAT2B 5648 -KAT5 881 -KAT6A 4015 -KAT6B 3929 -KAT7 1378 -KAT8 2311 -KATNA1 552 -KATNAL1 1700 -KATNAL2 481 -KATNB1 1176 -KATNBL1 513 -KATNBL1P6 66 -KAZALD1 29 -KAZN 1462 -KBTBD11 5 -KBTBD11-OT1 0 -KBTBD12 76 -KBTBD13 6 -KBTBD2 2139 -KBTBD3 208 -KBTBD4 221 -KBTBD6 1639 -KBTBD7 183 -KBTBD8 137 -KC6 9 -KCCAT198 0 -KCCAT211 4 -KCCAT333 1 -KCMF1 2128 -KCNA1 104 -KCNA10 0 -KCNA2 230 -KCNA3 1520 -KCNA4 213 -KCNA5 1081 -KCNA6 2453 -KCNA7 2 -KCNAB1 813 -KCNAB1-AS1 0 -KCNAB1-AS2 0 -KCNAB2 2385 -KCNAB3 159 -KCNB1 503 -KCNB2 136 -KCNC1 1258 -KCNC2 934 -KCNC3 1263 -KCNC4 1492 -KCNC4-AS1 6 -KCND1 344 -KCND2 763 -KCND3 302 -KCND3-AS1 1 -KCND3-IT1 0 -KCNE1 5 -KCNE2 23 -KCNE3 167 -KCNE4 777 -KCNE5 52 -KCNF1 341 -KCNG1 1080 -KCNG2 64 -KCNG3 61 -KCNG4 7 -KCNH1 303 -KCNH2 3403 -KCNH3 674 -KCNH4 122 -KCNH5 44 -KCNH6 121 -KCNH7 43 -KCNH8 154 -KCNIP1 743 -KCNIP2 894 -KCNIP2-AS1 47 -KCNIP3 819 -KCNIP4 789 -KCNIP4-IT1 20 -KCNJ1 5 -KCNJ10 4648 -KCNJ11 268 -KCNJ12 112 -KCNJ13 61 -KCNJ14 178 -KCNJ15 25 -KCNJ16 1015 -KCNJ18 0 -KCNJ2 351 -KCNJ2-AS1 28 -KCNJ3 1439 -KCNJ4 443 -KCNJ5 186 -KCNJ6 222 -KCNJ8 468 -KCNJ9 1998 -KCNK1 1040 -KCNK10 168 -KCNK12 350 -KCNK13 124 -KCNK15 30 -KCNK16 1 -KCNK17 22 -KCNK18 1 -KCNK2 584 -KCNK3 1118 -KCNK4 138 -KCNK5 125 -KCNK6 92 -KCNK7 63 -KCNK9 389 -KCNMA1 3710 -KCNMA1-AS1 6 -KCNMA1-AS2 3 -KCNMA1-AS3 3 -KCNMB1 116 -KCNMB2 57 -KCNMB2-AS1 6 -KCNMB3 175 -KCNMB4 1152 -KCNN1 421 -KCNN2 360 -KCNN3 3806 -KCNN4 60 -KCNQ1 36 -KCNQ1-AS1 2 -KCNQ1DN 0 -KCNQ1OT1 2134 -KCNQ2 624 -KCNQ3 2229 -KCNQ4 440 -KCNQ5 682 -KCNQ5-AS1 6 -KCNQ5-IT1 1 -KCNRG 13 -KCNS1 42 -KCNS2 78 -KCNS3 213 -KCNT1 998 -KCNT2 339 -KCNU1 0 -KCNV1 67 -KCNV2 8 -KCP 13 -KCTD1 1403 -KCTD10 2427 -KCTD11 572 -KCTD12 4136 -KCTD13 1470 -KCTD14 1 -KCTD15 2389 -KCTD16 107 -KCTD17 1642 -KCTD18 521 -KCTD19 34 -KCTD2 2866 -KCTD20 2355 -KCTD21 1178 -KCTD21-AS1 13 -KCTD3 1703 -KCTD4 325 -KCTD5 700 -KCTD6 1025 -KCTD7 1538 -KCTD8 264 -KCTD9 330 -KDELC1 131 -KDELC2 970 -KDELR1 3916 -KDELR2 2815 -KDELR3 149 -KDF1 70 -KDM1A 2007 -KDM1B 854 -KDM2A 7311 -KDM2B 886 -KDM3A 2297 -KDM3B 2962 -KDM4A 1514 -KDM4A-AS1 39 -KDM4B 2140 -KDM4C 1187 -KDM4D 20 -KDM4E 4 -KDM5A 3787 -KDM5B 1379 -KDM5C 6929 -KDM5D 0 -KDM6A 1230 -KDM6B 4964 -KDM7A 744 -KDM8 227 -KDR 1371 -KDSR 2587 -KEAP1 2631 -KEL 0 -KERA 1 -KGFLP1 25 -KGFLP2 159 -KHDC1 254 -KHDC1L 6 -KHDC3L 2 -KHDRBS1 3421 -KHDRBS2 178 -KHDRBS3 1085 -KHK 262 -KHNYN 2100 -KHSRP 5811 -KIAA0020 565 -KIAA0040 829 -KIAA0087 26 -KIAA0100 5350 -KIAA0101 22 -KIAA0125 5 -KIAA0141 1368 -KIAA0195 3883 -KIAA0196 1140 -KIAA0226 3968 -KIAA0226L 658 -KIAA0232 2462 -KIAA0319 706 -KIAA0319L 3714 -KIAA0355 641 -KIAA0368 3831 -KIAA0391 568 -KIAA0408 2 -KIAA0430 0 -KIAA0513 5171 -KIAA0556 1769 -KIAA0586 627 -KIAA0753 1040 -KIAA0754 421 -KIAA0825 164 -KIAA0895 849 -KIAA0895L 2170 -KIAA0907 2238 -KIAA0922 178 -KIAA0930 11500 -KIAA1024 99 -KIAA1024L 5 -KIAA1033 1236 -KIAA1107 1139 -KIAA1109 8957 -KIAA1143 516 -KIAA1147 0 -KIAA1161 2099 -KIAA1191 5416 -KIAA1210 4 -KIAA1211 1292 -KIAA1211L 415 -KIAA1217 1244 -KIAA1257 46 -KIAA1279 1588 -KIAA1324 2895 -KIAA1324L 663 -KIAA1328 334 -KIAA1407 764 -KIAA1429 1299 -KIAA1456 1305 -KIAA1462 3446 -KIAA1467 1357 -KIAA1468 1455 -KIAA1522 2082 -KIAA1524 57 -KIAA1549 1987 -KIAA1549L 1445 -KIAA1551 1515 -KIAA1586 290 -KIAA1614 230 -KIAA1644 1728 -KIAA1656 327 -KIAA1671 3318 -KIAA1683 429 -KIAA1715 1402 -KIAA1755 1067 -KIAA1804 206 -KIAA1841 685 -KIAA1875 403 -KIAA1919 389 -KIAA1958 810 -KIAA2012 317 -KIAA2013 1084 -KIAA2018 1109 -KIAA2022 848 -KIAA2026 4481 -KIDINS220 5937 -KIF11 46 -KIF12 38 -KIF13A 2285 -KIF13B 2611 -KIF14 36 -KIF15 47 -KIF16B 738 -KIF17 915 -KIF18A 67 -KIF18B 20 -KIF19 290 -KIF1A 44811 -KIF1B 13108 -KIF1C 23316 -KIF20A 7 -KIF20B 103 -KIF21A 7523 -KIF21B 2688 -KIF22 503 -KIF23 15 -KIF24 168 -KIF25 23 -KIF25-AS1 7 -KIF26A 331 -KIF26B 21 -KIF27 568 -KIF2A 1794 -KIF2B 0 -KIF2C 49 -KIF3A 5121 -KIF3B 6027 -KIF3C 5842 -KIF4A 36 -KIF4B 3 -KIF5A 7220 -KIF5B 11332 -KIF5C 8444 -KIF6 218 -KIF7 828 -KIF9 421 -KIF9-AS1 170 -KIFAP3 2793 -KIFC1 0 -KIFC2 3405 -KIFC3 2120 -KIN 607 -KIR2DL1 0 -KIR2DL2 0 -KIR2DL3 0 -KIR2DL4 0 -KIR2DL5A 0 -KIR2DL5B 0 -KIR2DS1 0 -KIR2DS2 0 -KIR2DS3 0 -KIR2DS4 0 -KIR2DS5 0 -KIR3DL1 0 -KIR3DL2 0 -KIR3DL3 0 -KIR3DS1 0 -KIR3DX1 0 -KIRREL 2659 -KIRREL2 14 -KIRREL3 475 -KIRREL3-AS2 10 -KIRREL3-AS3 1 -KISS1 487 -KISS1R 76 -KIT 451 -KITLG 1006 -KIZ 729 -KIZ-AS1 12 -KL 128 -KLB 50 -KLC1 8810 -KLC2 5981 -KLC3 35 -KLC4 1586 -KLF1 1 -KLF10 597 -KLF11 394 -KLF12 1616 -KLF13 83 -KLF14 15 -KLF15 3079 -KLF16 1720 -KLF17 7 -KLF2 1110 -KLF3 2008 -KLF3-AS1 159 -KLF4 592 -KLF5 494 -KLF6 3627 -KLF7 3127 -KLF8 327 -KLF9 1773 -KLHDC1 359 -KLHDC10 3887 -KLHDC2 1611 -KLHDC3 3604 -KLHDC4 449 -KLHDC7A 6 -KLHDC7B 11 -KLHDC8A 5324 -KLHDC8B 1401 -KLHDC9 570 -KLHL1 484 -KLHL10 5 -KLHL11 1229 -KLHL12 1774 -KLHL13 457 -KLHL14 38 -KLHL15 739 -KLHL17 659 -KLHL18 1226 -KLHL2 2226 -KLHL20 560 -KLHL21 3967 -KLHL22 1465 -KLHL23 14 -KLHL24 2770 -KLHL25 1609 -KLHL26 858 -KLHL28 659 -KLHL29 782 -KLHL3 823 -KLHL30 32 -KLHL31 23 -KLHL32 583 -KLHL33 8 -KLHL34 41 -KLHL35 164 -KLHL36 1974 -KLHL38 13 -KLHL4 98 -KLHL40 1 -KLHL41 121 -KLHL42 1639 -KLHL5 5644 -KLHL6 724 -KLHL6-AS1 5 -KLHL7 1258 -KLHL7-AS1 11 -KLHL8 1146 -KLHL9 1474 -KLK1 0 -KLK10 36 -KLK11 3 -KLK12 0 -KLK13 1 -KLK14 75 -KLK15 0 -KLK2 0 -KLK3 0 -KLK4 7 -KLK5 20 -KLK6 684 -KLK7 62 -KLK8 9 -KLK9 0 -KLKB1 349 -KLKP1 1 -KLLN 47 -KLRAP1 52 -KLRB1 17 -KLRC1 15 -KLRC2 15 -KLRC3 44 -KLRC4 3 -KLRC4-KLRK1 0 -KLRD1 17 -KLRF1 8 -KLRF2 0 -KLRG1 118 -KLRG2 9 -KLRK1 0 -KMO 40 -KMT2A 8632 -KMT2B 3380 -KMT2C 7425 -KMT2D 8442 -KMT2E 7160 -KMT2E-AS1 476 -KNCN 56 -KNDC1 4831 -KNG1 0 -KNOP1 2399 -KNSTRN 210 -KNTC1 205 -KPNA1 2483 -KPNA2 697 -KPNA3 1461 -KPNA4 3164 -KPNA5 422 -KPNA6 4805 -KPNA7 2 -KPNB1 4695 -KPRP 0 -KPTN 618 -KRAS 1574 -KRBA1 526 -KRBA2 410 -KRBOX1 22 -KRBOX1-AS1 0 -KRBOX4 499 -KRCC1 1656 -KREMEN1 981 -KREMEN2 15 -KRI1 1775 -KRIT1 1799 -KRR1 617 -KRT1 1 -KRT10 948 -KRT12 0 -KRT13 1 -KRT14 8 -KRT15 7 -KRT16 0 -KRT16P1 0 -KRT16P2 0 -KRT16P3 0 -KRT17 1 -KRT17P5 1 -KRT18 154 -KRT18P55 6 -KRT19 206 -KRT19P2 0 -KRT2 0 -KRT20 0 -KRT222 250 -KRT23 0 -KRT24 0 -KRT25 0 -KRT26 0 -KRT27 0 -KRT28 0 -KRT3 4 -KRT31 0 -KRT32 2 -KRT33A 0 -KRT33B 0 -KRT34 0 -KRT35 0 -KRT36 1 -KRT37 0 -KRT38 0 -KRT39 0 -KRT4 0 -KRT40 0 -KRT42P 9 -KRT5 11 -KRT6A 0 -KRT6B 0 -KRT6C 0 -KRT7 14 -KRT71 0 -KRT72 0 -KRT73 0 -KRT73-AS1 0 -KRT74 0 -KRT75 0 -KRT76 0 -KRT77 1 -KRT78 0 -KRT79 1 -KRT8 169 -KRT80 1 -KRT81 2 -KRT82 0 -KRT83 1 -KRT84 0 -KRT85 0 -KRT86 18 -KRT8P41 4 -KRT9 0 -KRTAP1-1 0 -KRTAP1-3 0 -KRTAP1-4 0 -KRTAP1-5 0 -KRTAP10-1 2 -KRTAP10-10 0 -KRTAP10-11 0 -KRTAP10-12 0 -KRTAP10-2 3 -KRTAP10-3 0 -KRTAP10-4 0 -KRTAP10-5 0 -KRTAP10-6 0 -KRTAP10-7 0 -KRTAP10-8 0 -KRTAP10-9 0 -KRTAP11-1 0 -KRTAP12-1 0 -KRTAP12-2 0 -KRTAP12-3 0 -KRTAP12-4 0 -KRTAP13-1 0 -KRTAP13-2 4 -KRTAP13-3 0 -KRTAP13-4 0 -KRTAP15-1 0 -KRTAP16-1 0 -KRTAP17-1 0 -KRTAP19-1 0 -KRTAP19-2 0 -KRTAP19-3 0 -KRTAP19-4 0 -KRTAP19-5 0 -KRTAP19-6 0 -KRTAP19-7 0 -KRTAP19-8 0 -KRTAP2-1 0 -KRTAP2-2 0 -KRTAP2-3 0 -KRTAP2-4 0 -KRTAP20-1 0 -KRTAP20-2 0 -KRTAP20-3 0 -KRTAP20-4 0 -KRTAP21-1 0 -KRTAP21-2 0 -KRTAP21-3 0 -KRTAP22-1 0 -KRTAP22-2 0 -KRTAP23-1 0 -KRTAP24-1 0 -KRTAP25-1 0 -KRTAP26-1 0 -KRTAP27-1 0 -KRTAP29-1 0 -KRTAP3-1 0 -KRTAP3-2 0 -KRTAP3-3 0 -KRTAP4-1 0 -KRTAP4-11 0 -KRTAP4-12 0 -KRTAP4-2 0 -KRTAP4-3 0 -KRTAP4-4 0 -KRTAP4-5 0 -KRTAP4-6 0 -KRTAP4-7 0 -KRTAP4-8 0 -KRTAP4-9 0 -KRTAP5-1 0 -KRTAP5-10 2 -KRTAP5-11 5 -KRTAP5-2 0 -KRTAP5-3 0 -KRTAP5-4 1 -KRTAP5-5 0 -KRTAP5-6 0 -KRTAP5-7 5 -KRTAP5-8 12 -KRTAP5-9 31 -KRTAP5-AS1 3 -KRTAP6-1 0 -KRTAP6-2 0 -KRTAP6-3 0 -KRTAP7-1 0 -KRTAP8-1 0 -KRTAP9-1 0 -KRTAP9-2 0 -KRTAP9-3 0 -KRTAP9-4 0 -KRTAP9-6 0 -KRTAP9-7 0 -KRTAP9-8 0 -KRTAP9-9 0 -KRTCAP2 1443 -KRTCAP3 98 -KRTDAP 4 -KSR1 757 -KSR2 1388 -KTI12 0 -KTN1 12264 -KTN1-AS1 27 -KU-MEL-3 0 -KXD1 2288 -KY 356 -KYNU 29 -L1CAM 8485 -L1TD1 8 -L2HGDH 264 -L3HYPDH 178 -L3MBTL1 739 -L3MBTL2 1595 -L3MBTL3 842 -L3MBTL4 279 -L3MBTL4-AS1 34 -LACAT8 1 -LACC1 323 -LACE1 112 -LACRT 0 -LACTB 495 -LACTB2 142 -LACTB2-AS1 20 -LACTBL1 0 -LAD1 1 -LAG3 89 -LAGE3 705 -LAIR1 81 -LAIR2 0 -LALBA 0 -LAMA1 446 -LAMA2 5697 -LAMA3 871 -LAMA4 2151 -LAMA5 6890 -LAMA5-AS1 17 -LAMB1 671 -LAMB2 8859 -LAMB2P1 70 -LAMB3 140 -LAMB4 20 -LAMC1 3476 -LAMC2 37 -LAMC3 572 -LAMP1 7143 -LAMP2 4767 -LAMP3 37 -LAMP5 321 -LAMP5-AS1 1 -LAMTOR1 2579 -LAMTOR2 761 -LAMTOR3 1474 -LAMTOR4 1454 -LAMTOR5 1463 -LAMTOR5-AS1 8 -LANCL1 2503 -LANCL1-AS1 9 -LANCL2 1045 -LANCL3 153 -LAP3 2485 -LAPTM4A 4538 -LAPTM4B 1532 -LAPTM5 3124 -LARGE 820 -LARGE-AS1 5 -LARP1 11648 -LARP1B 1118 -LARP4 3205 -LARP4B 1770 -LARP6 2106 -LARP7 5503 -LARS 3415 -LARS2 964 -LARS2-AS1 24 -LAS1L 930 -LASP1 6726 -LAT 249 -LAT2 1434 -LATS1 1492 -LATS2 1408 -LAX1 6 -LAYN 434 -LBH 2199 -LBHD1 76 -LBP 4 -LBR 668 -LBX1 0 -LBX1-AS1 1 -LBX2 25 -LBX2-AS1 36 -LCA10 4 -LCA5 1480 -LCA5L 70 -LCAL1 0 -LCAT 747 -LCE1A 0 -LCE1B 0 -LCE1C 0 -LCE1D 0 -LCE1E 0 -LCE1F 0 -LCE2A 0 -LCE2B 0 -LCE2C 0 -LCE2D 0 -LCE3A 0 -LCE3B 0 -LCE3C 0 -LCE3D 0 -LCE3E 0 -LCE4A 0 -LCE5A 2 -LCE6A 0 -LCK 51 -LCLAT1 305 -LCMT1 1102 -LCMT1-AS1 7 -LCMT1-AS2 27 -LCMT2 329 -LCN1 15 -LCN10 1217 -LCN12 101 -LCN15 0 -LCN2 4 -LCN6 131 -LCN8 6 -LCN9 0 -LCNL1 581 -LCOR 1226 -LCORL 408 -LCP1 1445 -LCP2 412 -LCT 8 -LCTL 47 -LDAH 559 -LDB1 1901 -LDB2 715 -LDB3 317 -LDHA 5659 -LDHAL6A 42 -LDHAL6B 28 -LDHB 10030 -LDHC 5 -LDHD 404 -LDLR 3140 -LDLRAD1 1 -LDLRAD2 98 -LDLRAD3 1285 -LDLRAD4 1682 -LDLRAD4-AS1 35 -LDLRAP1 764 -LDOC1 3052 -LDOC1L 2399 -LEAP2 52 -LECT1 52 -LECT2 2 -LEF1 979 -LEF1-AS1 13 -LEFTY1 107 -LEFTY2 1791 -LEKR1 17 -LELP1 0 -LEMD1 6 -LEMD1-AS1 22 -LEMD2 2217 -LEMD3 951 -LENEP 10 -LENG1 1 -LENG8 1 -LENG8-AS1 1 -LENG9 0 -LEO1 598 -LEP 1 -LEPR 1088 -LEPROT 1437 -LEPROTL1 1360 -LETM1 1861 -LETM2 409 -LETMD1 923 -LEUTX 0 -LFNG 456 -LGALS1 4432 -LGALS12 2 -LGALS13 0 -LGALS14 1 -LGALS16 1 -LGALS17A 5 -LGALS2 8 -LGALS3 1277 -LGALS3BP 8289 -LGALS4 57 -LGALS7 0 -LGALS7B 0 -LGALS8 1748 -LGALS8-AS1 1 -LGALS9 989 -LGALS9B 3 -LGALS9C 0 -LGALSL 515 -LGI1 1123 -LGI2 287 -LGI3 1906 -LGI4 2483 -LGMN 1297 -LGR4 1653 -LGR5 389 -LGR6 1984 -LGSN 15 -LHB 75 -LHCGR 54 -LHFP 2715 -LHFPL1 61 -LHFPL2 1780 -LHFPL3 604 -LHFPL3-AS1 3 -LHFPL3-AS2 3 -LHFPL4 1580 -LHFPL5 68 -LHPP 2419 -LHX1 6 -LHX2 1750 -LHX3 2 -LHX4 50 -LHX4-AS1 342 -LHX5 136 -LHX5-AS1 70 -LHX6 150 -LHX8 2 -LHX9 12 -LIAS 274 -LIF 70 -LIFR 4203 -LIFR-AS1 132 -LIG1 693 -LIG3 470 -LIG4 1184 -LILRA1 13 -LILRA2 0 -LILRA3 0 -LILRA4 0 -LILRA5 0 -LILRA6 11 -LILRB1 46 -LILRB2 20 -LILRB3 1 -LILRB4 8 -LILRB5 0 -LILRP2 0 -LIM2 1 -LIMA1 835 -LIMCH1 8746 -LIMD1 579 -LIMD1-AS1 3 -LIMD2 601 -LIME1 988 -LIMK1 3372 -LIMK2 1411 -LIMS1 734 -LIMS2 1452 -LIMS3 0 -LIMS3-LOC440895 0 -LIMS3L 0 -LIN28A 2 -LIN28B 44 -LIN37 407 -LIN52 337 -LIN54 525 -LIN7A 125 -LIN7B 419 -LIN7C 1233 -LIN9 80 -LINC-PINT 1840 -LINC-ROR 0 -LINC00028 0 -LINC00029 0 -LINC00032 8 -LINC00051 1 -LINC00052 0 -LINC00092 140 -LINC00094 1638 -LINC00102 0 -LINC00106 7 -LINC00111 0 -LINC00112 0 -LINC00113 0 -LINC00114 0 -LINC00115 60 -LINC00116 605 -LINC00152 80 -LINC00158 14 -LINC00159 0 -LINC00160 0 -LINC00161 3 -LINC00162 4 -LINC00163 5 -LINC00167 14 -LINC00173 79 -LINC00174 779 -LINC00176 101 -LINC00184 7 -LINC00189 10 -LINC00200 0 -LINC00202-1 633 -LINC00202-2 32 -LINC00207 1 -LINC00208 0 -LINC00210 0 -LINC00211 0 -LINC00221 0 -LINC00222 10 -LINC00226 0 -LINC00229 1 -LINC00235 0 -LINC00238 3 -LINC00239 3 -LINC00240 19 -LINC00242 0 -LINC00243 0 -LINC00244 2 -LINC00251 0 -LINC00254 0 -LINC00260 285 -LINC00261 0 -LINC00264 10 -LINC00265 278 -LINC00266-1 1 -LINC00266-3 1 -LINC00269 1 -LINC00271 34 -LINC00272 1 -LINC00273 0 -LINC00276 0 -LINC00278 0 -LINC00280 0 -LINC00282 95 -LINC00284 58 -LINC00290 12 -LINC00293 0 -LINC00294 1459 -LINC00297 0 -LINC00298 18 -LINC00299 37 -LINC00301 0 -LINC00303 3 -LINC00304 54 -LINC00305 0 -LINC00307 0 -LINC00308 0 -LINC00309 0 -LINC00310 49 -LINC00311 13 -LINC00312 84 -LINC00313 3 -LINC00314 1 -LINC00316 3 -LINC00317 0 -LINC00319 4 -LINC00320 254 -LINC00322 0 -LINC00323 48 -LINC00324 96 -LINC00326 0 -LINC00327 35 -LINC00330 0 -LINC00331 0 -LINC00332 0 -LINC00333 0 -LINC00336 3 -LINC00337 7 -LINC00339 318 -LINC00341 209 -LINC00342 1626 -LINC00343 0 -LINC00346 12 -LINC00347 2 -LINC00348 0 -LINC00350 0 -LINC00351 0 -LINC00353 0 -LINC00354 1 -LINC00358 0 -LINC00359 1 -LINC00363 0 -LINC00364 0 -LINC00365 0 -LINC00366 0 -LINC00367 0 -LINC00368 9 -LINC00371 1 -LINC00375 0 -LINC00376 0 -LINC00377 1 -LINC00378 0 -LINC00379 0 -LINC00380 0 -LINC00381 0 -LINC00382 0 -LINC00383 0 -LINC00392 0 -LINC00395 0 -LINC00396 5 -LINC00397 0 -LINC00398 2 -LINC00399 0 -LINC00400 47 -LINC00403 176 -LINC00408 0 -LINC00410 0 -LINC00411 0 -LINC00412 3 -LINC00417 1 -LINC00421 0 -LINC00423 0 -LINC00424 0 -LINC00426 9 -LINC00428 0 -LINC00431 7 -LINC00433 0 -LINC00434 0 -LINC00437 0 -LINC00440 0 -LINC00441 5 -LINC00442 0 -LINC00443 6 -LINC00445 0 -LINC00446 0 -LINC00448 0 -LINC00452 1 -LINC00456 0 -LINC00457 0 -LINC00458 0 -LINC00460 4 -LINC00461 462 -LINC00462 0 -LINC00463 9 -LINC00466 2 -LINC00467 73 -LINC00469 0 -LINC00470 5 -LINC00471 65 -LINC00472 431 -LINC00473 591 -LINC00474 0 -LINC00475 5 -LINC00476 432 -LINC00477 2 -LINC00479 0 -LINC00482 25 -LINC00483 2 -LINC00485 0 -LINC00486 5 -LINC00487 39 -LINC00488 23 -LINC00489 0 -LINC00491 2 -LINC00492 1 -LINC00493 754 -LINC00494 3 -LINC00499 1 -LINC00501 1 -LINC00502 0 -LINC00504 9 -LINC00506 22 -LINC00507 3 -LINC00508 1 -LINC00511 10 -LINC00514 7 -LINC00515 27 -LINC00518 0 -LINC00520 7 -LINC00521 1 -LINC00523 0 -LINC00524 1 -LINC00525 3 -LINC00526 130 -LINC00528 24 -LINC00534 1 -LINC00535 14 -LINC00536 0 -LINC00538 6 -LINC00539 24 -LINC00540 10 -LINC00544 0 -LINC00545 0 -LINC00547 0 -LINC00548 1 -LINC00550 0 -LINC00551 9 -LINC00552 2 -LINC00554 0 -LINC00557 1 -LINC00558 0 -LINC00559 0 -LINC00562 4 -LINC00563 5 -LINC00564 0 -LINC00565 53 -LINC00566 0 -LINC00570 0 -LINC00571 1 -LINC00572 0 -LINC00574 3 -LINC00575 1 -LINC00577 1 -LINC00578 2 -LINC00581 5 -LINC00582 3 -LINC00583 0 -LINC00587 0 -LINC00588 0 -LINC00589 0 -LINC00592 0 -LINC00593 0 -LINC00595 22 -LINC00597 22 -LINC00598 9 -LINC00599 1260 -LINC00601 7 -LINC00602 14 -LINC00603 0 -LINC00605 0 -LINC00606 1 -LINC00607 16 -LINC00608 0 -LINC00609 13 -LINC00612 120 -LINC00613 2 -LINC00615 0 -LINC00616 0 -LINC00618 1 -LINC00619 0 -LINC00620 7 -LINC00622 37 -LINC00623 335 -LINC00624 1 -LINC00626 0 -LINC00628 3 -LINC00629 5 -LINC00630 78 -LINC00632 1976 -LINC00633 2 -LINC00634 646 -LINC00635 0 -LINC00636 0 -LINC00637 2 -LINC00638 100 -LINC00639 66 -LINC00640 5 -LINC00641 3330 -LINC00642 10 -LINC00643 1329 -LINC00644 2 -LINC00645 62 -LINC00648 94 -LINC00649 42 -LINC00652 12 -LINC00654 90 -LINC00656 0 -LINC00657 12614 -LINC00658 7 -LINC00659 1 -LINC00661 0 -LINC00662 160 -LINC00663 294 -LINC00664 15 -LINC00665 412 -LINC00667 1072 -LINC00668 0 -LINC00669 1 -LINC00670 2 -LINC00671 3 -LINC00672 980 -LINC00673 562 -LINC00674 4468 -LINC00675 22 -LINC00676 1 -LINC00678 1 -LINC00681 2 -LINC00682 3 -LINC00683 18 -LINC00684 0 -LINC00685 18 -LINC00687 0 -LINC00689 50 -LINC00690 0 -LINC00691 2 -LINC00692 0 -LINC00693 161 -LINC00696 0 -LINC00698 1 -LINC00700 0 -LINC00701 0 -LINC00702 0 -LINC00703 0 -LINC00704 3 -LINC00705 0 -LINC00706 4 -LINC00707 54 -LINC00708 0 -LINC00709 0 -LINC00710 0 -LINC00824 0 -LINC00836 199 -LINC00837 0 -LINC00838 0 -LINC00839 367 -LINC00840 15 -LINC00841 0 -LINC00842 4 -LINC00844 609 -LINC00845 0 -LINC00847 754 -LINC00850 0 -LINC00851 0 -LINC00852 39 -LINC00853 7 -LINC00854 21 -LINC00856 34 -LINC00857 18 -LINC00858 2 -LINC00861 40 -LINC00862 31 -LINC00864 2 -LINC00865 137 -LINC00866 1 -LINC00867 1 -LINC00869 227 -LINC00870 8 -LINC00871 0 -LINC00877 194 -LINC00879 0 -LINC00880 66 -LINC00881 6 -LINC00882 35 -LINC00883 229 -LINC00884 43 -LINC00885 0 -LINC00886 122 -LINC00887 5 -LINC00888 565 -LINC00889 179 -LINC00890 168 -LINC00891 0 -LINC00892 1 -LINC00893 146 -LINC00894 215 -LINC00895 3 -LINC00896 0 -LINC00898 0 -LINC00899 140 -LINC00900 77 -LINC00901 0 -LINC00904 0 -LINC00905 0 -LINC00906 39 -LINC00907 21 -LINC00908 26 -LINC00909 311 -LINC00910 65 -LINC00911 0 -LINC00917 0 -LINC00919 0 -LINC00920 2 -LINC00921 53 -LINC00922 2 -LINC00923 8 -LINC00924 122 -LINC00925 412 -LINC00926 110 -LINC00927 0 -LINC00928 34 -LINC00929 2 -LINC00930 59 -LINC00933 17 -LINC00934 2 -LINC00935 1 -LINC00936 185 -LINC00937 16 -LINC00938 537 -LINC00939 2 -LINC00940 3 -LINC00941 34 -LINC00942 33 -LINC00943 4 -LINC00944 0 -LINC00945 6 -LINC00950 536 -LINC00951 36 -LINC00954 23 -LINC00955 0 -LINC00957 340 -LINC00958 41 -LINC00959 142 -LINC00960 36 -LINC00961 29 -LINC00963 575 -LINC00964 8 -LINC00965 2 -LINC00967 3 -LINC00968 2 -LINC00969 6 -LINC00970 0 -LINC00971 0 -LINC00974 0 -LINC00977 0 -LINC00982 242 -LINC00987 204 -LINC00989 5 -LINC00992 1 -LINC00993 0 -LINC00994 6 -LINC00996 5 -LINC00997 685 -LINC00998 551 -LINC00999 331 -LINC01000 2057 -LINC01001 33 -LINC01002 13 -LINC01003 72 -LINC01004 3175 -LINC01005 0 -LINC01006 28 -LINC01007 0 -LINC01010 4 -LINC01011 149 -LINC01012 48 -LINC01013 4 -LINC01014 2 -LINC01015 0 -LINC01016 0 -LINC01017 0 -LINC01018 186 -LINC01019 2 -LINC01020 0 -LINC01021 0 -LINC01023 36 -LINC01024 153 -LINC01028 0 -LINC01029 1 -LINC01030 4 -LINC01031 1 -LINC01032 1 -LINC01033 0 -LINC01036 0 -LINC01038 0 -LINC01039 5 -LINC01040 0 -LINC01044 0 -LINC01046 0 -LINC01047 0 -LINC01048 0 -LINC01049 0 -LINC01050 0 -LINC01053 0 -LINC01054 0 -LINC01055 0 -LINC01056 0 -LINC01057 15 -LINC01058 4 -LINC01060 0 -LINC01061 290 -LINC01063 47 -LINC01065 0 -LINC01068 5 -LINC01069 5 -LINC01070 0 -LINC01072 0 -LINC01075 0 -LINC01080 3 -LINC01081 0 -LINC01082 0 -LINC01085 15 -LINC01087 0 -LINC01088 1475 -LINC01089 652 -LINC01090 0 -LINC01091 0 -LINC01093 4 -LINC01094 4860 -LINC01095 0 -LINC01096 1 -LINC01097 0 -LINC01098 0 -LINC01099 7 -LINC01100 0 -LINC01101 0 -LINC01102 22 -LINC01103 0 -LINC01104 0 -LINC01105 1160 -LINC01106 70 -LINC01107 3 -LINC01108 6 -LINC01111 0 -LINC01114 73 -LINC01115 0 -LINC01116 3 -LINC01117 2 -LINC01118 7 -LINC01119 24 -LINC01120 0 -LINC01121 5 -LINC01122 37 -LINC01123 52 -LINC01124 6 -LINC01125 165 -LINC01126 22 -LINC01127 33 -LINC01128 487 -LINC01132 15 -LINC01133 12 -LINC01134 18 -LINC01135 33 -LINC01136 1 -LINC01137 118 -LINC01138 490 -LINC01139 27 -LINC01140 56 -LINC01141 48 -LINC01142 0 -LINC01143 0 -LINC01144 48 -LINC01146 4 -LINC01150 9 -LINC01151 1 -LINC01152 180 -LINC01158 259 -LINC01159 52 -LINC01160 20 -LINC01162 0 -LINC01163 2 -LINC01164 2 -LINC01166 96 -LINC01167 2 -LINC01168 16 -LINC01169 2 -LINC01170 6 -LINC01176 111 -LINC01177 0 -LINC01179 0 -LINC01180 0 -LINC01182 1 -LINC01184 667 -LINC01185 4 -LINC01186 2 -LINC01187 0 -LINC01189 0 -LINC01191 3 -LINC01192 0 -LINC01193 0 -LINC01194 0 -LINC01195 1 -LINC01197 22 -LINC01198 3 -LINC01201 2 -LINC01202 0 -LINC01203 0 -LINC01204 0 -LINC01205 0 -LINC01206 48 -LINC01207 0 -LINC01208 1 -LINC01209 0 -LINC01210 5 -LINC01212 1 -LINC01213 2 -LINC01214 0 -LINC01215 0 -LINC01216 0 -LINC01219 0 -LINC01220 12 -LINC01221 0 -LINC01222 0 -LINC01224 2 -LINC01225 0 -LINC01226 1 -LINC01227 2 -LINC01229 2 -LINC01230 0 -LINC01231 2 -LINC01232 42 -LINC01233 1 -LINC01234 33 -LINC01237 1 -LINC01239 10 -LINC01241 2 -LINC01242 0 -LINC01246 0 -LINC01247 0 -LINC01248 0 -LINC01249 0 -LINC01250 5 -LINC01251 2 -LINC01252 60 -LINC01254 0 -LINC01255 0 -LINC01256 0 -LINC01257 0 -LINC01258 0 -LINC01260 33 -LINC01262 1 -LINC01264 0 -LINC01265 1 -LINC01266 13 -LINC01267 1 -LINC01268 54 -LINC01269 3 -LINC01270 19 -LINC01271 15 -LINC01272 16 -LINC01273 16 -LINC01276 0 -LINC01277 20 -LINC01278 1988 -LINC01279 170 -LINC01280 1 -LINC01281 0 -LINC01282 0 -LINC01284 4 -LINC01285 12 -LINC01287 0 -LINC01288 0 -LINC01289 0 -LINC01291 2 -LINC01296 6 -LINC01298 0 -LINC01299 1 -LINC01300 0 -LINC01301 106 -LINC01304 0 -LINC01305 6 -LINC01307 0 -LINC01309 0 -LINC01310 9 -LINC01311 36 -LINC01312 1 -LINC01314 1123 -LINC01315 162 -LINC01317 0 -LINC01320 0 -LINC01322 20 -LINC01324 0 -LINC01327 0 -LINC01330 20 -LINC01331 0 -LINC01333 0 -LINC01335 0 -LINC01336 0 -LINC01337 3 -LINC01338 140 -LINC01339 0 -LINC01340 0 -LINC01341 69 -LINC01342 2 -LINC01343 2 -LINC01344 0 -LINC01346 1 -LINC01347 51 -LINC01348 2 -LINC01349 3 -LINC01350 0 -LINC01351 62 -LINC01352 9 -LINC01353 5 -LINC01354 430 -LINC01355 619 -LINC01356 26 -LINC01358 3 -LINC01359 14 -LINC01360 0 -LINC01361 7 -LINC01363 2 -LINC01364 1 -LINC01365 0 -LINC01366 3 -LINC01370 0 -LINC01372 28 -LINC01375 0 -LINC01377 5 -LINC01378 0 -LINC01384 1 -LINC01386 0 -LINC01387 0 -LINC01389 3 -LINC01391 8 -LINC01392 0 -LINC01393 3 -LINC01395 0 -LINC01396 0 -LINC01397 3 -LINC01398 5 -LINC01399 5 -LINC01402 3 -LINC01405 0 -LINC01410 74 -LINC01411 46 -LINC01412 1 -LINC01413 0 -LINC01416 0 -LINC01419 0 -LINC01420 1108 -LINC01422 5 -LINC01423 0 -LINC01424 5 -LINC01425 0 -LINC01426 2 -LINC01427 0 -LINC01428 0 -LINC01429 0 -LINC01430 0 -LINC01431 15 -LINC01432 0 -LINC01433 14 -LINC01435 1 -LINC01436 19 -LINC01440 0 -LINC01441 0 -LINC01443 7 -LINC01444 1 -LINC01445 10 -LINC01446 0 -LINC01447 2 -LINC01448 0 -LINC01449 0 -LINC01450 0 -LINC01455 0 -LINC01461 9 -LINC01465 23 -LINC01467 0 -LINC01468 2 -LINC01470 2 -LINC01471 1 -LINC01473 21 -LINC01474 1 -LINC01475 0 -LINC01476 0 -LINC01477 0 -LINC01478 0 -LINC01479 0 -LINC01480 7 -LINC01481 121 -LINC01482 4 -LINC01483 0 -LINC01484 0 -LINC01485 35 -LINC01486 0 -LINC01487 0 -LINC01488 0 -LINC01489 1 -LINC01490 0 -LINC01491 0 -LINC01492 0 -LINC01493 0 -LINC01494 3 -LINC01495 0 -LINC01496 1 -LINC01497 6 -LINC01498 0 -LINC01499 0 -LINC01500 0 -LINC01501 4 -LINC01502 0 -LINC01503 75 -LINC01504 4 -LINC01505 0 -LINC01506 1 -LINC01507 0 -LINC01508 15 -LINC01509 1 -LINC01510 0 -LINC01511 1 -LINC01512 7 -LINC01514 6 -LINC01515 12 -LINC01516 30 -LINC01517 0 -LINC01518 0 -LINC01519 0 -LINC01520 0 -LINC01521 187 -LINC01522 2 -LINC01523 1 -LINC01524 0 -LINC01525 0 -LINC01526 0 -LINC01529 76 -LINC01530 78 -LINC01531 0 -LINC01532 369 -LINC01533 0 -LINC01534 73 -LINC01535 131 -LINC01537 5 -LINC01538 0 -LINC01539 2 -LINC01541 0 -LINC01543 0 -LINC01544 2 -LINC01545 3 -LINC01546 18 -LINC01547 66 -LINC01548 0 -LINC01549 13 -LINC01550 22 -LINC01551 1 -LINC01552 6 -LINC01553 0 -LINC01554 14 -LINC01555 1 -LINC01556 0 -LINC01558 4 -LINC01559 0 -LINC01560 113 -LINC01561 357 -LINC01563 51 -LINC01564 4 -LINC01565 0 -LINC01566 0 -LINC01567 391 -LINC01568 0 -LINC01569 68 -LINC01570 1 -LINC01571 1 -LINC01572 11 -LINC01573 7 -LINC01574 59 -LINC01578 2396 -LINC01580 4 -LINC01581 0 -LINC01582 0 -LINC01583 2 -LINC01584 0 -LINC01585 3 -LINC01586 40 -LINC01587 0 -LINC01588 57 -LINC01589 10 -LINC01590 28 -LINC01591 0 -LINC01592 0 -LINC01594 2 -LINC01599 9 -LINC01600 21 -LINC01602 1 -LINC01603 1 -LINC01604 125 -LINC01605 4 -LINC01606 1 -LINC01607 13 -LINC01608 0 -LINC01609 0 -LINC01611 0 -LINC01612 1 -LINCMD1 0 -LINCR-0001 23 -LINCR-0002 7 -LINCR-0003 3 -LINGO1 1411 -LINGO1-AS1 1 -LINGO1-AS2 0 -LINGO2 172 -LINGO3 127 -LINGO4 18 -LINS 271 -LIPA 1372 -LIPC 5 -LIPE 525 -LIPE-AS1 56 -LIPF 0 -LIPG 45 -LIPH 38 -LIPI 1 -LIPJ 0 -LIPK 0 -LIPM 0 -LIPN 0 -LIPT1 291 -LIPT2 35 -LITAF 2587 -LIX1 1073 -LIX1L 1190 -LKAAEAR1 47 -LL22NC01-81G9.3 0 -LL22NC03-63E9.3 0 -LL22NC03-75H12.2 1 -LLGL1 2945 -LLGL2 451 -LLPH 379 -LLPH-AS1 4 -LMAN1 4045 -LMAN1L 18 -LMAN2 3174 -LMAN2L 1891 -LMBR1 1312 -LMBR1L 887 -LMBRD1 3128 -LMBRD2 343 -LMCD1 716 -LMCD1-AS1 17 -LMF1 2399 -LMF1-AS1 23 -LMF2 2416 -LMLN 826 -LMLN-AS1 0 -LMNA 4855 -LMNB1 123 -LMNB2 2322 -LMNTD1 153 -LMNTD2 17 -LMO1 118 -LMO2 2643 -LMO3 2183 -LMO4 3759 -LMO7 628 -LMO7-AS1 14 -LMO7DN 14 -LMO7DN-IT1 5 -LMOD1 2019 -LMOD2 7 -LMOD3 2 -LMTK2 2106 -LMTK3 6457 -LMX1A 62 -LMX1B 126 -LNP1 224 -LNPEP 268 -LNX1 206 -LNX1-AS1 0 -LNX1-AS2 2 -LNX2 376 -LOC100049716 138 -LOC100101148 0 -LOC100101478 0 -LOC100126784 210 -LOC100128006 13 -LOC100128076 7 -LOC100128164 27 -LOC100128176 13 -LOC100128233 2 -LOC100128239 299 -LOC100128288 485 -LOC100128317 0 -LOC100128361 84 -LOC100128398 360 -LOC100128494 141 -LOC100128531 26 -LOC100128554 3 -LOC100128568 7 -LOC100128573 9 -LOC100128593 34 -LOC100128714 11 -LOC100128770 13 -LOC100128885 13 -LOC100128993 0 -LOC100129027 40 -LOC100129034 3240 -LOC100129046 10 -LOC100129055 0 -LOC100129083 1 -LOC100129138 9 -LOC100129148 2 -LOC100129175 1 -LOC100129203 57 -LOC100129216 0 -LOC100129307 1 -LOC100129316 30 -LOC100129345 0 -LOC100129434 62 -LOC100129461 45 -LOC100129518 32 -LOC100129520 0 -LOC100129534 186 -LOC100129550 355 -LOC100129603 2 -LOC100129617 255 -LOC100129620 8 -LOC100129636 0 -LOC100129697 26 -LOC100129917 614 -LOC100129924 0 -LOC100129931 27 -LOC100129935 2 -LOC100129940 159 -LOC100129973 51 -LOC100130075 12 -LOC100130093 149 -LOC100130238 188 -LOC100130264 3 -LOC100130298 6 -LOC100130331 1 -LOC100130357 132 -LOC100130370 16 -LOC100130417 38 -LOC100130451 4 -LOC100130452 0 -LOC100130476 14 -LOC100130587 18 -LOC100130673 13 -LOC100130691 167 -LOC100130700 1 -LOC100130705 377 -LOC100130744 533 -LOC100130849 0 -LOC100130872 35 -LOC100130880 1 -LOC100130899 11 -LOC100130950 218 -LOC100130964 0 -LOC100130987 51 -LOC100130992 115 -LOC100131047 0 -LOC100131107 0 -LOC100131257 7 -LOC100131289 8 -LOC100131303 1 -LOC100131315 0 -LOC100131347 10 -LOC100131496 40 -LOC100131532 24 -LOC100131564 969 -LOC100131626 7 -LOC100131635 0 -LOC100131655 28 -LOC100132057 218 -LOC100132062 0 -LOC100132077 20 -LOC100132078 0 -LOC100132111 20 -LOC100132146 2 -LOC100132174 1 -LOC100132215 214 -LOC100132287 0 -LOC100132304 0 -LOC100132356 221 -LOC100132735 1 -LOC100132741 0 -LOC100132781 11 -LOC100132831 11 -LOC100133050 1 -LOC100133077 20 -LOC100133091 24 -LOC100133267 0 -LOC100133286 11 -LOC100133315 18 -LOC100133331 53 -LOC100133461 0 -LOC100133669 57 -LOC100133920 7 -LOC100133985 68 -LOC100134317 18 -LOC100134368 52 -LOC100134391 0 -LOC100134868 23 -LOC100144595 16 -LOC100147773 35 -LOC100190940 3 -LOC100190986 41 -LOC100192426 5 -LOC100233156 341 -LOC100240728 0 -LOC100240734 0 -LOC100240735 1 -LOC100268168 72 -LOC100270746 25 -LOC100270804 49 -LOC100271832 1 -LOC100272216 1 -LOC100272217 135 -LOC100286922 0 -LOC100287010 0 -LOC100287015 89 -LOC100287036 10 -LOC100287042 26 -LOC100287072 15 -LOC100287225 19 -LOC100287592 5 -LOC100287632 2 -LOC100287704 0 -LOC100287728 0 -LOC100287792 2 -LOC100287834 0 -LOC100287846 424 -LOC100287944 2 -LOC100288069 73 -LOC100288123 40 -LOC100288152 582 -LOC100288162 25 -LOC100288181 125 -LOC100288254 0 -LOC100288570 0 -LOC100288637 2 -LOC100288748 0 -LOC100288778 73 -LOC100288798 40 -LOC100288842 19 -LOC100288846 53 -LOC100288866 5 -LOC100288911 32 -LOC100288966 0 -LOC100289230 235 -LOC100289333 6 -LOC100289361 32 -LOC100289473 27 -LOC100289495 49 -LOC100289511 45 -LOC100289561 12 -LOC100289580 61 -LOC100289650 14 -LOC100289656 0 -LOC100289673 0 -LOC100294145 1 -LOC100294362 224 -LOC100303749 3 -LOC100335030 6 -LOC100379224 145 -LOC100419583 14 -LOC100420587 1 -LOC100421746 0 -LOC100422212 0 -LOC100422556 26 -LOC100422737 2 -LOC100499194 1 -LOC100499484 141 -LOC100499484-C9ORF174 4 -LOC100499489 211 -LOC100500773 0 -LOC100505478 0 -LOC100505515 0 -LOC100505530 1 -LOC100505549 133 -LOC100505622 4 -LOC100505625 30 -LOC100505635 29 -LOC100505658 1 -LOC100505666 23 -LOC100505715 262 -LOC100505716 77 -LOC100505736 4 -LOC100505782 0 -LOC100505795 21 -LOC100505817 0 -LOC100505841 1 -LOC100505878 0 -LOC100505887 0 -LOC100505912 9 -LOC100505915 3 -LOC100505918 0 -LOC100505920 3 -LOC100505921 0 -LOC100505938 32 -LOC100505942 107 -LOC100505978 54 -LOC100505984 3 -LOC100506022 28 -LOC100506023 54 -LOC100506071 14 -LOC100506076 0 -LOC100506082 3 -LOC100506083 39 -LOC100506085 3 -LOC100506100 94 -LOC100506122 0 -LOC100506123 0 -LOC100506124 102 -LOC100506125 10 -LOC100506127 308 -LOC100506136 75 -LOC100506142 55 -LOC100506159 3 -LOC100506175 3 -LOC100506178 17 -LOC100506188 0 -LOC100506207 39 -LOC100506258 43 -LOC100506271 0 -LOC100506272 0 -LOC100506274 0 -LOC100506281 8 -LOC100506302 78 -LOC100506314 30 -LOC100506321 7 -LOC100506368 11 -LOC100506371 2 -LOC100506384 10 -LOC100506388 3 -LOC100506393 0 -LOC100506403 0 -LOC100506406 0 -LOC100506422 1 -LOC100506444 0 -LOC100506457 5 -LOC100506470 0 -LOC100506472 278 -LOC100506474 20 -LOC100506476 17 -LOC100506497 219 -LOC100506526 20 -LOC100506548 2891 -LOC100506551 37 -LOC100506585 70 -LOC100506603 173 -LOC100506606 55 -LOC100506639 201 -LOC100506675 12 -LOC100506679 26 -LOC100506682 2 -LOC100506688 0 -LOC100506700 4 -LOC100506725 78 -LOC100506730 602 -LOC100506746 260 -LOC100506747 0 -LOC100506790 0 -LOC100506801 14 -LOC100506804 7 -LOC100506834 7 -LOC100506844 373 -LOC100506858 0 -LOC100506860 22 -LOC100506869 1 -LOC100506895 2 -LOC100506985 71 -LOC100506990 757 -LOC100507002 60 -LOC100507006 16 -LOC100507053 71 -LOC100507065 2 -LOC100507073 0 -LOC100507091 17 -LOC100507140 10 -LOC100507144 53 -LOC100507156 19 -LOC100507175 0 -LOC100507194 137 -LOC100507195 2 -LOC100507201 0 -LOC100507205 0 -LOC100507250 10 -LOC100507283 56 -LOC100507291 21 -LOC100507334 0 -LOC100507346 4 -LOC100507351 353 -LOC100507373 432 -LOC100507377 0 -LOC100507384 0 -LOC100507387 162 -LOC100507388 2 -LOC100507389 1 -LOC100507391 0 -LOC100507406 0 -LOC100507412 4 -LOC100507424 48 -LOC100507431 4 -LOC100507437 122 -LOC100507443 0 -LOC100507462 23 -LOC100507468 7 -LOC100507472 38 -LOC100507477 4 -LOC100507487 99 -LOC100507506 14 -LOC100507534 78 -LOC100507537 0 -LOC100507547 8 -LOC100507557 129 -LOC100507564 31 -LOC100507577 548 -LOC100507600 0 -LOC100507634 39 -LOC100507639 11 -LOC100507642 3 -LOC100507661 20 -LOC100508046 0 -LOC100630923 12 -LOC100631378 8 -LOC100652758 71 -LOC100652768 56 -LOC100652931 0 -LOC100652999 4 -LOC100653233 1 -LOC100996249 0 -LOC100996251 139 -LOC100996255 29 -LOC100996263 0 -LOC100996286 4 -LOC100996291 20 -LOC100996324 0 -LOC100996325 0 -LOC100996338 0 -LOC100996342 28 -LOC100996349 0 -LOC100996351 30 -LOC100996385 54 -LOC100996437 47 -LOC100996447 60 -LOC100996455 36 -LOC100996579 0 -LOC100996583 1 -LOC100996634 20 -LOC100996635 1 -LOC100996654 2 -LOC100996671 0 -LOC100996679 0 -LOC100996693 29 -LOC100996694 1 -LOC101054525 5 -LOC101059948 14 -LOC101060019 0 -LOC101060091 20 -LOC101060321 0 -LOC101060385 0 -LOC101060389 0 -LOC101060498 7 -LOC101060524 0 -LOC101060542 2 -LOC101060553 23 -LOC101241902 8 -LOC101243545 135 -LOC101409256 45 -LOC101448202 0 -LOC101559451 10 -LOC101593348 21 -LOC101805491 0 -LOC101926889 8 -LOC101926892 7 -LOC101926897 7 -LOC101926898 4 -LOC101926905 4 -LOC101926908 0 -LOC101926911 22 -LOC101926913 16 -LOC101926915 7 -LOC101926933 7 -LOC101926935 240 -LOC101926940 1 -LOC101926941 12 -LOC101926942 0 -LOC101926943 6 -LOC101926944 7 -LOC101926955 0 -LOC101926960 0 -LOC101926962 0 -LOC101926963 33 -LOC101926964 52 -LOC101926966 1 -LOC101926975 17 -LOC101927018 4 -LOC101927020 0 -LOC101927021 158 -LOC101927023 1 -LOC101927027 501 -LOC101927040 14 -LOC101927043 35 -LOC101927045 23 -LOC101927048 0 -LOC101927051 10 -LOC101927053 2 -LOC101927055 84 -LOC101927056 14 -LOC101927058 0 -LOC101927062 3 -LOC101927066 10 -LOC101927069 77 -LOC101927070 24 -LOC101927078 4 -LOC101927079 0 -LOC101927081 0 -LOC101927082 0 -LOC101927087 1 -LOC101927100 31 -LOC101927120 0 -LOC101927123 1 -LOC101927124 54 -LOC101927131 1 -LOC101927132 4 -LOC101927136 0 -LOC101927139 2 -LOC101927142 5 -LOC101927143 48 -LOC101927151 315 -LOC101927153 0 -LOC101927156 0 -LOC101927157 4 -LOC101927159 7 -LOC101927164 55 -LOC101927166 0 -LOC101927178 35 -LOC101927179 2 -LOC101927181 314 -LOC101927188 26 -LOC101927189 12 -LOC101927190 10 -LOC101927196 22 -LOC101927204 109 -LOC101927207 0 -LOC101927211 13 -LOC101927229 0 -LOC101927230 0 -LOC101927237 55 -LOC101927239 0 -LOC101927243 2 -LOC101927244 0 -LOC101927248 139 -LOC101927257 27 -LOC101927267 21 -LOC101927269 0 -LOC101927272 21 -LOC101927274 2 -LOC101927282 0 -LOC101927284 6 -LOC101927285 1 -LOC101927286 0 -LOC101927292 1 -LOC101927296 4 -LOC101927305 0 -LOC101927310 1 -LOC101927311 52 -LOC101927314 7 -LOC101927318 4 -LOC101927322 18 -LOC101927334 0 -LOC101927342 0 -LOC101927348 0 -LOC101927354 60 -LOC101927356 1 -LOC101927358 0 -LOC101927359 112 -LOC101927365 62 -LOC101927374 12 -LOC101927378 0 -LOC101927379 2 -LOC101927391 103 -LOC101927394 14 -LOC101927406 0 -LOC101927410 0 -LOC101927411 0 -LOC101927412 0 -LOC101927415 30 -LOC101927416 7 -LOC101927418 6 -LOC101927419 0 -LOC101927421 0 -LOC101927431 0 -LOC101927434 0 -LOC101927437 4 -LOC101927438 4 -LOC101927446 11 -LOC101927450 0 -LOC101927460 0 -LOC101927464 0 -LOC101927468 7 -LOC101927472 4 -LOC101927476 2 -LOC101927478 0 -LOC101927481 21 -LOC101927482 1 -LOC101927488 0 -LOC101927495 0 -LOC101927497 3 -LOC101927501 0 -LOC101927502 4 -LOC101927523 5 -LOC101927526 0 -LOC101927539 16 -LOC101927543 1 -LOC101927549 0 -LOC101927550 263 -LOC101927557 1 -LOC101927560 0 -LOC101927571 0 -LOC101927572 13 -LOC101927575 8 -LOC101927577 0 -LOC101927580 4 -LOC101927583 26 -LOC101927587 10 -LOC101927588 9 -LOC101927592 1 -LOC101927604 7 -LOC101927606 0 -LOC101927616 0 -LOC101927619 0 -LOC101927620 0 -LOC101927623 7 -LOC101927630 0 -LOC101927636 13 -LOC101927637 0 -LOC101927640 0 -LOC101927641 6 -LOC101927650 0 -LOC101927651 5 -LOC101927653 1 -LOC101927657 0 -LOC101927661 0 -LOC101927666 3 -LOC101927668 10 -LOC101927683 0 -LOC101927686 1 -LOC101927691 1 -LOC101927692 45 -LOC101927694 2 -LOC101927697 0 -LOC101927701 0 -LOC101927708 1 -LOC101927709 1 -LOC101927730 21 -LOC101927735 1 -LOC101927740 0 -LOC101927746 14 -LOC101927755 26 -LOC101927762 1 -LOC101927765 34 -LOC101927766 1 -LOC101927768 8 -LOC101927769 0 -LOC101927770 16 -LOC101927780 3 -LOC101927787 0 -LOC101927795 2 -LOC101927797 0 -LOC101927798 0 -LOC101927811 21 -LOC101927814 2 -LOC101927815 0 -LOC101927817 10 -LOC101927822 4 -LOC101927827 0 -LOC101927829 1 -LOC101927830 0 -LOC101927835 0 -LOC101927839 1 -LOC101927843 0 -LOC101927844 1 -LOC101927845 0 -LOC101927847 0 -LOC101927849 0 -LOC101927851 3 -LOC101927854 1 -LOC101927865 3 -LOC101927869 2 -LOC101927870 15 -LOC101927876 0 -LOC101927881 1 -LOC101927884 0 -LOC101927901 0 -LOC101927905 39 -LOC101927907 1 -LOC101927911 5 -LOC101927914 2 -LOC101927915 0 -LOC101927919 1 -LOC101927924 4 -LOC101927926 1 -LOC101927932 9 -LOC101927934 1 -LOC101927948 0 -LOC101927950 10 -LOC101927954 6 -LOC101927964 0 -LOC101927967 0 -LOC101927969 8 -LOC101927972 2 -LOC101927973 2 -LOC101927987 5 -LOC101928002 0 -LOC101928008 2 -LOC101928009 0 -LOC101928012 0 -LOC101928020 76 -LOC101928030 0 -LOC101928034 2 -LOC101928035 1 -LOC101928043 7 -LOC101928048 2 -LOC101928052 0 -LOC101928053 38 -LOC101928063 12 -LOC101928068 41 -LOC101928069 18 -LOC101928075 20 -LOC101928093 0 -LOC101928100 41 -LOC101928103 54 -LOC101928105 6 -LOC101928107 0 -LOC101928118 20 -LOC101928128 1 -LOC101928131 0 -LOC101928134 8 -LOC101928135 0 -LOC101928137 0 -LOC101928140 0 -LOC101928150 9 -LOC101928161 16 -LOC101928162 0 -LOC101928163 0 -LOC101928167 0 -LOC101928168 0 -LOC101928174 8 -LOC101928191 2 -LOC101928201 0 -LOC101928203 0 -LOC101928205 12 -LOC101928211 0 -LOC101928222 15 -LOC101928226 0 -LOC101928227 0 -LOC101928231 2 -LOC101928233 3 -LOC101928241 0 -LOC101928253 0 -LOC101928254 1 -LOC101928259 0 -LOC101928266 38 -LOC101928269 1 -LOC101928270 1 -LOC101928272 0 -LOC101928273 0 -LOC101928279 15 -LOC101928280 0 -LOC101928283 4 -LOC101928295 18 -LOC101928298 0 -LOC101928303 29 -LOC101928304 16 -LOC101928306 0 -LOC101928307 498 -LOC101928314 0 -LOC101928322 7 -LOC101928323 69 -LOC101928324 10 -LOC101928327 1 -LOC101928333 0 -LOC101928335 22 -LOC101928336 2 -LOC101928358 69 -LOC101928370 51 -LOC101928371 1 -LOC101928372 0 -LOC101928381 0 -LOC101928386 7 -LOC101928398 0 -LOC101928401 12 -LOC101928402 11 -LOC101928404 2 -LOC101928414 17 -LOC101928416 10 -LOC101928417 2 -LOC101928418 0 -LOC101928435 35 -LOC101928436 2 -LOC101928437 0 -LOC101928438 4 -LOC101928441 1 -LOC101928443 0 -LOC101928445 22 -LOC101928446 3 -LOC101928449 0 -LOC101928453 3 -LOC101928460 7 -LOC101928461 18 -LOC101928471 0 -LOC101928476 3 -LOC101928489 34 -LOC101928491 17 -LOC101928495 0 -LOC101928505 0 -LOC101928509 14 -LOC101928514 17 -LOC101928516 0 -LOC101928517 3 -LOC101928519 7 -LOC101928523 0 -LOC101928525 10 -LOC101928530 19 -LOC101928535 1 -LOC101928539 0 -LOC101928540 0 -LOC101928551 3 -LOC101928565 0 -LOC101928567 0 -LOC101928569 0 -LOC101928580 2 -LOC101928590 61 -LOC101928597 6 -LOC101928600 0 -LOC101928605 2 -LOC101928618 0 -LOC101928622 0 -LOC101928626 0 -LOC101928650 10 -LOC101928651 2 -LOC101928661 0 -LOC101928663 3 -LOC101928673 98 -LOC101928674 21 -LOC101928682 4 -LOC101928694 0 -LOC101928696 6 -LOC101928697 0 -LOC101928700 1 -LOC101928708 1 -LOC101928710 3 -LOC101928718 4 -LOC101928730 0 -LOC101928731 4 -LOC101928737 3 -LOC101928738 6 -LOC101928739 0 -LOC101928748 0 -LOC101928751 1 -LOC101928766 3 -LOC101928767 4 -LOC101928769 0 -LOC101928775 0 -LOC101928778 0 -LOC101928782 0 -LOC101928786 5 -LOC101928790 10 -LOC101928791 0 -LOC101928794 10 -LOC101928796 17 -LOC101928797 6 -LOC101928804 0 -LOC101928809 0 -LOC101928812 49 -LOC101928823 5 -LOC101928834 3 -LOC101928837 1 -LOC101928841 238 -LOC101928844 3 -LOC101928847 51 -LOC101928851 0 -LOC101928855 26 -LOC101928858 10 -LOC101928861 1 -LOC101928865 4 -LOC101928880 6 -LOC101928882 12 -LOC101928885 12 -LOC101928886 2 -LOC101928891 15 -LOC101928894 0 -LOC101928896 0 -LOC101928909 15 -LOC101928911 0 -LOC101928936 0 -LOC101928937 0 -LOC101928940 1 -LOC101928942 0 -LOC101928943 10 -LOC101928944 7 -LOC101928961 7 -LOC101928973 1 -LOC101928977 4 -LOC101928978 0 -LOC101928979 5 -LOC101928988 3 -LOC101928989 1 -LOC101928992 5 -LOC101928994 1 -LOC101928995 10 -LOC101929019 0 -LOC101929023 1 -LOC101929034 0 -LOC101929057 57 -LOC101929058 0 -LOC101929064 4 -LOC101929066 83 -LOC101929073 0 -LOC101929076 4 -LOC101929080 0 -LOC101929084 0 -LOC101929089 41 -LOC101929095 0 -LOC101929099 2 -LOC101929106 43 -LOC101929116 0 -LOC101929122 18 -LOC101929123 0 -LOC101929124 0 -LOC101929125 61 -LOC101929128 1 -LOC101929140 27 -LOC101929144 7 -LOC101929147 188 -LOC101929148 3 -LOC101929153 0 -LOC101929154 0 -LOC101929162 19 -LOC101929164 3 -LOC101929172 0 -LOC101929181 1 -LOC101929194 1 -LOC101929199 0 -LOC101929207 0 -LOC101929210 0 -LOC101929217 1 -LOC101929224 17 -LOC101929229 0 -LOC101929231 14 -LOC101929234 36 -LOC101929237 13 -LOC101929239 2 -LOC101929241 0 -LOC101929259 0 -LOC101929260 0 -LOC101929268 5 -LOC101929279 0 -LOC101929282 0 -LOC101929284 0 -LOC101929294 2 -LOC101929295 10 -LOC101929297 0 -LOC101929312 0 -LOC101929315 0 -LOC101929319 0 -LOC101929331 22 -LOC101929337 0 -LOC101929340 36 -LOC101929353 0 -LOC101929371 13 -LOC101929372 189 -LOC101929374 0 -LOC101929378 1 -LOC101929380 4 -LOC101929384 7 -LOC101929395 6 -LOC101929406 0 -LOC101929412 4 -LOC101929413 0 -LOC101929415 4 -LOC101929420 0 -LOC101929427 8 -LOC101929431 1 -LOC101929439 3 -LOC101929441 2 -LOC101929448 1 -LOC101929450 3 -LOC101929452 0 -LOC101929454 0 -LOC101929464 1 -LOC101929468 0 -LOC101929470 2 -LOC101929473 1 -LOC101929486 0 -LOC101929488 0 -LOC101929497 1 -LOC101929504 0 -LOC101929505 9 -LOC101929512 3 -LOC101929516 2 -LOC101929517 0 -LOC101929524 10 -LOC101929526 0 -LOC101929528 0 -LOC101929529 1 -LOC101929532 37 -LOC101929541 13 -LOC101929549 48 -LOC101929550 15 -LOC101929551 0 -LOC101929555 236 -LOC101929563 8 -LOC101929565 7 -LOC101929567 6 -LOC101929570 0 -LOC101929572 0 -LOC101929574 20 -LOC101929577 14 -LOC101929579 3 -LOC101929584 0 -LOC101929586 26 -LOC101929592 5 -LOC101929595 9 -LOC101929596 7 -LOC101929607 18 -LOC101929608 0 -LOC101929613 1 -LOC101929622 4 -LOC101929625 0 -LOC101929626 2 -LOC101929631 0 -LOC101929633 1 -LOC101929645 0 -LOC101929646 0 -LOC101929653 18 -LOC101929657 11 -LOC101929660 0 -LOC101929662 0 -LOC101929679 43 -LOC101929680 12 -LOC101929681 0 -LOC101929694 0 -LOC101929696 7 -LOC101929698 15 -LOC101929705 48 -LOC101929709 162 -LOC101929710 1 -LOC101929715 10 -LOC101929717 28 -LOC101929718 187 -LOC101929719 1 -LOC101929721 0 -LOC101929723 1 -LOC101929733 21 -LOC101929741 13 -LOC101929753 3 -LOC101929754 2 -LOC101929762 5 -LOC101929767 298 -LOC101929771 0 -LOC101929829 0 -LOC101929897 0 -LOC101929983 0 -LOC101930010 6 -LOC101930071 47 -LOC101930452 8 -LOC102031319 1 -LOC102467079 0 -LOC102467080 0 -LOC102467081 2 -LOC102467147 9 -LOC102467212 1 -LOC102467213 0 -LOC102467214 8 -LOC102467216 1 -LOC102467217 0 -LOC102467222 0 -LOC102467223 0 -LOC102467224 4 -LOC102467225 0 -LOC102467226 0 -LOC102467655 2 -LOC102477328 4 -LOC102503427 1 -LOC102546226 27 -LOC102546228 0 -LOC102546229 1 -LOC102546294 41 -LOC102546298 7 -LOC102546299 5 -LOC102577426 0 -LOC102606465 219 -LOC102606466 0 -LOC102723330 0 -LOC102723344 3 -LOC102723354 20 -LOC102723362 0 -LOC102723373 1 -LOC102723376 0 -LOC102723377 0 -LOC102723385 5 -LOC102723427 0 -LOC102723439 9 -LOC102723448 2 -LOC102723505 1 -LOC102723517 4 -LOC102723544 1 -LOC102723582 6 -LOC102723604 0 -LOC102723617 0 -LOC102723649 0 -LOC102723661 0 -LOC102723701 23 -LOC102723703 67 -LOC102723704 36 -LOC102723709 1 -LOC102723729 3 -LOC102723766 0 -LOC102723769 0 -LOC102723778 1 -LOC102723780 30 -LOC102723809 20 -LOC102723824 4 -LOC102723828 1 -LOC102723831 0 -LOC102723833 0 -LOC102723854 13 -LOC102723883 2 -LOC102723885 10 -LOC102723895 0 -LOC102723927 10 -LOC102723968 1 -LOC102724000 0 -LOC102724009 18 -LOC102724020 0 -LOC102724034 0 -LOC102724050 36 -LOC102724053 1 -LOC102724058 7 -LOC102724084 0 -LOC102724094 111 -LOC102724096 0 -LOC102724153 1 -LOC102724163 4 -LOC102724188 0 -LOC102724190 12 -LOC102724201 3 -LOC102724238 0 -LOC102724279 0 -LOC102724297 9 -LOC102724301 12 -LOC102724312 43 -LOC102724321 0 -LOC102724323 0 -LOC102724421 0 -LOC102724434 0 -LOC102724450 5 -LOC102724467 22 -LOC102724484 8 -LOC102724511 0 -LOC102724539 0 -LOC102724552 10 -LOC102724555 0 -LOC102724589 4 -LOC102724596 32 -LOC102724601 1 -LOC102724604 28 -LOC102724612 1 -LOC102724623 1 -LOC102724651 0 -LOC102724659 2 -LOC102724661 0 -LOC102724663 5 -LOC102724691 10 -LOC102724699 109 -LOC102724710 0 -LOC102724719 5 -LOC102724776 0 -LOC102724784 1 -LOC102724804 1 -LOC102724814 562 -LOC102724849 0 -LOC102724874 0 -LOC102724890 0 -LOC102724913 0 -LOC102724919 7 -LOC102724927 11 -LOC102724933 1 -LOC102724957 0 -LOC102724958 1 -LOC102725079 0 -LOC102800447 0 -LOC103021295 0 -LOC103021296 2 -LOC103091866 68 -LOC103171574 0 -LOC103191607 0 -LOC103312105 0 -LOC103344931 615 -LOC103352541 0 -LOC103611081 686 -LOC103908605 6 -LOC104054148 2 -LOC104613533 0 -LOC104968399 6 -LOC105274304 24 -LOC105370306 0 -LOC105372441 0 -LOC105372795 175 -LOC105373300 16 -LOC105373383 56 -LOC105373609 0 -LOC105375734 1 -LOC105376360 1 -LOC105376671 36 -LOC105377348 174 -LOC105378732 14 -LOC105447645 31 -LOC105447648 1 -LOC105616981 1 -LOC105667213 0 -LOC105747689 7 -LOC105748977 1 -LOC105755953 0 -LOC106099130 5 -LOC113230 413 -LOC115110 0 -LOC143666 0 -LOC145474 68 -LOC145783 206 -LOC145845 0 -LOC146513 0 -LOC146880 1207 -LOC148413 479 -LOC148696 215 -LOC148709 14 -LOC149373 0 -LOC149684 10 -LOC149950 2 -LOC150776 1786 -LOC150935 0 -LOC151121 4 -LOC151174 68 -LOC151475 9 -LOC151484 31 -LOC152225 0 -LOC152578 1 -LOC153684 108 -LOC153910 4 -LOC154449 0 -LOC154761 7 -LOC155060 539 -LOC157273 0 -LOC158434 44 -LOC158435 8 -LOC171391 335 -LOC1720 0 -LOC200726 17 -LOC200772 23 -LOC202181 514 -LOC220729 592 -LOC221122 0 -LOC221946 4 -LOC253573 0 -LOC254028 0 -LOC254896 4 -LOC255187 1 -LOC255654 1 -LOC256880 0 -LOC257396 162 -LOC283038 11 -LOC283045 55 -LOC283140 49 -LOC283177 30 -LOC283194 0 -LOC283214 0 -LOC283299 0 -LOC283332 6 -LOC283335 480 -LOC283352 1 -LOC283440 4 -LOC283575 10 -LOC283585 0 -LOC283683 144 -LOC283710 0 -LOC283731 16 -LOC283788 847 -LOC283856 49 -LOC283922 212 -LOC284009 55 -LOC284023 277 -LOC284080 7 -LOC284294 0 -LOC284344 0 -LOC284379 1 -LOC284395 16 -LOC284412 69 -LOC284454 447 -LOC284578 47 -LOC284581 487 -LOC284632 8 -LOC284648 10 -LOC284661 1 -LOC284788 0 -LOC284798 31 -LOC284825 2 -LOC284865 3 -LOC284930 0 -LOC284933 36 -LOC284950 7 -LOC285000 0 -LOC285043 0 -LOC285074 168 -LOC285484 109 -LOC285593 11 -LOC285626 0 -LOC285627 0 -LOC285629 0 -LOC285692 1 -LOC285696 93 -LOC285740 33 -LOC285762 2 -LOC285766 1 -LOC285768 5 -LOC285804 0 -LOC285819 15 -LOC285847 45 -LOC285889 18 -LOC286059 2 -LOC286083 0 -LOC286114 0 -LOC286177 0 -LOC286238 0 -LOC286297 0 -LOC286359 1 -LOC286370 0 -LOC286437 1348 -LOC338694 1 -LOC338797 0 -LOC338963 6 -LOC339059 17 -LOC339166 0 -LOC339260 0 -LOC339298 1 -LOC339529 10 -LOC339539 0 -LOC339568 0 -LOC339593 0 -LOC339622 1 -LOC339666 48 -LOC339803 258 -LOC339807 0 -LOC339862 0 -LOC339874 24 -LOC339975 4 -LOC340017 0 -LOC340074 0 -LOC340107 0 -LOC340113 0 -LOC340357 0 -LOC340512 4 -LOC341056 0 -LOC343052 0 -LOC344887 11 -LOC344967 198 -LOC349160 0 -LOC374443 95 -LOC375196 66 -LOC387810 0 -LOC388242 0 -LOC388282 0 -LOC388406 0 -LOC388436 0 -LOC388692 0 -LOC388780 39 -LOC388813 2 -LOC388849 38 -LOC388882 13 -LOC388942 1 -LOC389033 0 -LOC389199 0 -LOC389247 32 -LOC389332 25 -LOC389602 4 -LOC389641 23 -LOC389705 123 -LOC389765 524 -LOC389831 29 -LOC389834 562 -LOC389895 61 -LOC389906 127 -LOC390705 0 -LOC391003 0 -LOC391322 6 -LOC392196 4 -LOC392232 1 -LOC392364 0 -LOC392452 0 -LOC399715 34 -LOC399815 17 -LOC399886 4 -LOC400043 128 -LOC400541 1 -LOC400548 21 -LOC400553 0 -LOC400558 7 -LOC400620 0 -LOC400655 0 -LOC400661 5 -LOC400684 27 -LOC400685 3 -LOC400706 303 -LOC400736 0 -LOC400794 2 -LOC400867 8 -LOC400927 30 -LOC400927-CSNK1E 13 -LOC400940 139 -LOC400958 2 -LOC400997 1 -LOC401010 57 -LOC401052 23 -LOC401127 152 -LOC401134 9 -LOC401177 0 -LOC401242 0 -LOC401286 2 -LOC401312 0 -LOC401320 873 -LOC401324 1 -LOC401357 5 -LOC401463 18 -LOC401557 0 -LOC401585 1 -LOC403312 56 -LOC403323 15 -LOC407835 27 -LOC414300 3 -LOC439933 14 -LOC439994 31 -LOC440028 12 -LOC440040 16 -LOC440117 0 -LOC440173 3 -LOC440300 5 -LOC440311 387 -LOC440390 1 -LOC440434 191 -LOC440446 5 -LOC440461 22 -LOC440600 15 -LOC440602 0 -LOC440700 0 -LOC440704 0 -LOC440895 0 -LOC440896 7 -LOC440910 1 -LOC440982 98 -LOC441025 0 -LOC441081 27 -LOC441155 4 -LOC441178 0 -LOC441204 125 -LOC441242 88 -LOC441454 68 -LOC441455 108 -LOC441601 24 -LOC441666 59 -LOC442028 2 -LOC442132 2 -LOC442497 5 -LOC494127 4 -LOC494141 0 -LOC51145 0 -LOC541472 6 -LOC541473 7 -LOC550113 3 -LOC553103 142 -LOC55338 4 -LOC554206 64 -LOC554223 0 -LOC554249 0 -LOC574538 2 -LOC606724 0 -LOC613037 821 -LOC613038 0 -LOC613266 2 -LOC63930 0 -LOC641367 0 -LOC641746 0 -LOC642361 41 -LOC642366 429 -LOC642423 2 -LOC642426 0 -LOC642846 17 -LOC642852 3590 -LOC642929 2 -LOC642943 0 -LOC643072 179 -LOC643201 77 -LOC643339 5 -LOC643355 171 -LOC643387 7 -LOC643406 3 -LOC643441 0 -LOC643542 3 -LOC643623 6 -LOC643711 4 -LOC643733 101 -LOC643770 3 -LOC643802 4 -LOC643923 2 -LOC644145 1 -LOC644172 0 -LOC644189 29 -LOC644285 322 -LOC644554 52 -LOC644656 103 -LOC644669 0 -LOC644762 17 -LOC644838 0 -LOC644919 0 -LOC644936 1 -LOC645166 11 -LOC645354 0 -LOC645382 0 -LOC645434 1 -LOC645513 48 -LOC645752 4 -LOC645949 1 -LOC646029 5 -LOC646214 49 -LOC646268 1 -LOC646471 487 -LOC646522 0 -LOC646626 9 -LOC646736 0 -LOC646743 0 -LOC646762 1183 -LOC646813 0 -LOC646903 130 -LOC646938 0 -LOC647323 1 -LOC647859 42 -LOC648987 96 -LOC649133 0 -LOC649324 0 -LOC649352 0 -LOC650226 88 -LOC650293 0 -LOC652276 191 -LOC653160 54 -LOC653513 160 -LOC653602 105 -LOC653653 70 -LOC653712 61 -LOC653786 4 -LOC654342 7 -LOC654841 71 -LOC727751 3 -LOC727896 816 -LOC727924 0 -LOC728024 130 -LOC728040 0 -LOC728084 17 -LOC728095 7 -LOC728175 3 -LOC728323 88 -LOC728392 15512 -LOC728485 114 -LOC728554 82 -LOC728613 293 -LOC728673 7 -LOC728730 172 -LOC728739 18 -LOC728743 575 -LOC728752 22 -LOC728989 15 -LOC729080 15 -LOC729083 16 -LOC729159 0 -LOC729218 363 -LOC729296 3 -LOC729348 0 -LOC729506 1 -LOC729603 134 -LOC729609 5 -LOC729658 163 -LOC729683 136 -LOC729732 409 -LOC729737 118 -LOC729739 10 -LOC729867 89 -LOC729930 2 -LOC729950 1 -LOC729966 0 -LOC729970 216 -LOC729987 9 -LOC730101 197 -LOC730102 212 -LOC730159 0 -LOC730183 64 -LOC730202 7 -LOC730668 8 -LOC731157 0 -LOC731424 7 -LOC79160 4 -LOC79999 0 -LOC81691 41 -LOC90246 53 -LOC90768 339 -LOC90784 487 -LOC91450 17 -LOC93622 892 -LOH12CR1 300 -LOH12CR2 143 -LONP1 3178 -LONP2 3089 -LONRF1 902 -LONRF2 16285 -LONRF3 223 -LOR 8 -LOX 175 -LOXHD1 21 -LOXL1 270 -LOXL1-AS1 51 -LOXL2 163 -LOXL3 357 -LOXL4 107 -LPA 39 -LPAL2 30 -LPAR1 1929 -LPAR2 319 -LPAR3 31 -LPAR4 93 -LPAR5 296 -LPAR6 640 -LPCAT1 352 -LPCAT2 540 -LPCAT3 570 -LPCAT4 2311 -LPGAT1 2062 -LPIN1 4472 -LPIN2 2982 -LPIN3 581 -LPL 425 -LPO 9 -LPP 4885 -LPP-AS1 1 -LPP-AS2 89 -LPPR1 0 -LPPR2 5631 -LPPR3 2237 -LPPR4 1483 -LPPR5 382 -LPXN 326 -LRAT 1034 -LRBA 900 -LRCH1 1248 -LRCH2 796 -LRCH3 462 -LRCH4 2606 -LRCOL1 3 -LRFN1 1126 -LRFN2 184 -LRFN3 603 -LRFN4 1231 -LRFN5 473 -LRG1 146 -LRGUK 84 -LRIF1 1643 -LRIG1 5489 -LRIG2 482 -LRIG3 321 -LRIT1 3 -LRIT2 26 -LRIT3 56 -LRMP 176 -LRP1 24208 -LRP1-AS 15 -LRP10 4272 -LRP11 1542 -LRP12 602 -LRP1B 1518 -LRP2 359 -LRP2BP 1118 -LRP3 3973 -LRP4 9301 -LRP4-AS1 25 -LRP5 2604 -LRP5L 409 -LRP6 1939 -LRP8 1195 -LRPAP1 6916 -LRPPRC 1999 -LRR1 74 -LRRC1 709 -LRRC10 2 -LRRC10B 269 -LRRC14 1028 -LRRC14B 11 -LRRC15 2 -LRRC16A 780 -LRRC16B 1135 -LRRC17 43 -LRRC18 7 -LRRC19 39 -LRRC2 271 -LRRC2-AS1 0 -LRRC20 635 -LRRC23 924 -LRRC24 1 -LRRC25 79 -LRRC26 30 -LRRC27 849 -LRRC28 190 -LRRC29 100 -LRRC3 234 -LRRC3-AS1 16 -LRRC30 0 -LRRC31 1 -LRRC32 1003 -LRRC34 248 -LRRC36 70 -LRRC37A 1 -LRRC37A11P 6 -LRRC37A2 1 -LRRC37A3 639 -LRRC37A4P 24 -LRRC37A5P 2 -LRRC37A6P 386 -LRRC37A8P 0 -LRRC37B 547 -LRRC37BP1 560 -LRRC38 9 -LRRC39 70 -LRRC3B 368 -LRRC3C 0 -LRRC4 617 -LRRC40 351 -LRRC41 2122 -LRRC42 493 -LRRC43 203 -LRRC45 572 -LRRC46 254 -LRRC47 1928 -LRRC48 591 -LRRC49 747 -LRRC4B 9008 -LRRC4C 742 -LRRC52 2 -LRRC55 419 -LRRC56 38 -LRRC57 630 -LRRC58 2101 -LRRC59 1474 -LRRC6 638 -LRRC61 1123 -LRRC63 31 -LRRC66 328 -LRRC69 19 -LRRC7 333 -LRRC70 13 -LRRC71 121 -LRRC72 0 -LRRC73 309 -LRRC74A 0 -LRRC74B 162 -LRRC75A 209 -LRRC75A-AS1 5281 -LRRC75B 530 -LRRC8A 7265 -LRRC8B 584 -LRRC8C 713 -LRRC8D 2468 -LRRC8E 20 -LRRC9 216 -LRRCC1 1072 -LRRD1 13 -LRRFIP1 3900 -LRRFIP2 3010 -LRRIQ1 1420 -LRRIQ3 33 -LRRIQ4 15 -LRRK1 371 -LRRK2 1773 -LRRN1 731 -LRRN2 1873 -LRRN3 1177 -LRRN4 23 -LRRN4CL 95 -LRRTM1 353 -LRRTM2 1231 -LRRTM3 417 -LRRTM4 213 -LRSAM1 1698 -LRTM1 0 -LRTM2 314 -LRTOMT 608 -LRWD1 885 -LSAMP 8108 -LSAMP-AS1 2 -LSG1 1395 -LSM1 952 -LSM10 1336 -LSM11 428 -LSM12 114 -LSM14A 9 -LSM14B 1558 -LSM2 0 -LSM3 654 -LSM4 1985 -LSM5 503 -LSM6 298 -LSM7 851 -LSM8 899 -LSMEM1 711 -LSMEM2 32 -LSP1 235 -LSP1P3 3 -LSR 912 -LSS 318 -LST1 5 -LTA 6 -LTA4H 1660 -LTB 0 -LTB4R 122 -LTB4R2 13 -LTBP1 1016 -LTBP2 1871 -LTBP3 11554 -LTBP4 5023 -LTBR 1307 -LTC4S 71 -LTF 410 -LTK 20 -LTN1 916 -LTV1 566 -LUC7L 2743 -LUC7L2 298 -LUC7L3 14494 -LUCAT1 26 -LUM 201 -LUNAR1 0 -LURAP1 170 -LURAP1L 145 -LURAP1L-AS1 7 -LUZP1 2189 -LUZP2 1031 -LUZP4 0 -LUZP6 0 -LVCAT1 13 -LVCAT5 1 -LVCAT8 0 -LVRN 35 -LXN 242 -LY6D 0 -LY6E 0 -LY6G5B 0 -LY6G5C 0 -LY6G6C 0 -LY6G6D 0 -LY6G6E 0 -LY6G6F 0 -LY6H 1 -LY6K 10 -LY75 34 -LY75-CD302 0 -LY86 206 -LY86-AS1 1 -LY9 14 -LY96 73 -LYAR 758 -LYG1 94 -LYG2 25 -LYL1 256 -LYN 588 -LYNX1 6591 -LYPD1 1056 -LYPD2 0 -LYPD3 14 -LYPD4 0 -LYPD5 317 -LYPD6 210 -LYPD6B 43 -LYPD8 1 -LYPLA1 232 -LYPLA2 779 -LYPLA2P2 9 -LYPLAL1 338 -LYPLAL1-AS1 18 -LYRM1 746 -LYRM2 1653 -LYRM4 692 -LYRM5 741 -LYRM7 1000 -LYRM9 661 -LYSMD1 408 -LYSMD2 1053 -LYSMD3 1342 -LYSMD4 398 -LYST 2585 -LYVE1 575 -LYZ 334 -LYZL1 0 -LYZL2 0 -LYZL4 1 -LYZL6 0 -LZIC 524 -LZTFL1 1203 -LZTR1 2957 -LZTS1 270 -LZTS1-AS1 1 -LZTS2 2513 -LZTS3 4324 -M1AP 75 -M6PR 1316 -MAATS1 823 -MAB21L1 54 -MAB21L2 58 -MAB21L3 23 -MACC1 15 -MACC1-AS1 0 -MACF1 20833 -MACROD1 545 -MACROD2 378 -MACROD2-AS1 1 -MACROD2-IT1 0 -MAD1L1 503 -MAD2L1 41 -MAD2L1BP 422 -MAD2L2 697 -MADCAM1 82 -MADD 3781 -MAEA 2256 -MAEL 51 -MAF 3021 -MAF1 3139 -MAFA 31 -MAFA-AS1 8 -MAFB 864 -MAFF 2615 -MAFG 5492 -MAFG-AS1 112 -MAFIP 677 -MAFK 3171 -MAFTRR 7 -MAG 906 -MAGEA1 0 -MAGEA10 0 -MAGEA10-MAGEA5 0 -MAGEA11 0 -MAGEA12 3 -MAGEA2 0 -MAGEA2B 0 -MAGEA3 0 -MAGEA4 0 -MAGEA5 0 -MAGEA6 0 -MAGEA8 4 -MAGEA8-AS1 1 -MAGEA9 0 -MAGEA9B 0 -MAGEB1 0 -MAGEB10 0 -MAGEB16 0 -MAGEB17 3 -MAGEB18 0 -MAGEB2 0 -MAGEB3 1 -MAGEB4 0 -MAGEB5 0 -MAGEB6 0 -MAGEC1 1 -MAGEC2 0 -MAGEC3 36 -MAGED1 8122 -MAGED2 4964 -MAGED4 0 -MAGED4B 0 -MAGEE1 1602 -MAGEE2 164 -MAGEF1 1815 -MAGEH1 2311 -MAGEL2 2593 -MAGI1 2397 -MAGI1-AS1 4 -MAGI2 2115 -MAGI2-AS2 0 -MAGI2-AS3 2061 -MAGI3 1671 -MAGIX 281 -MAGOH 386 -MAGOH2P 21 -MAGOHB 178 -MAGT1 2477 -MAK 157 -MAK16 489 -MAL 446 -MAL2 180 -MALAT1 501838 -MALL 23 -MALRD1 38 -MALSU1 448 -MALT1 687 -MAMDC2 169 -MAMDC2-AS1 4 -MAMDC4 1181 -MAML1 1793 -MAML2 1897 -MAML3 613 -MAMLD1 1527 -MAMSTR 78 -MAN1A1 1064 -MAN1A2 7296 -MAN1B1 1610 -MAN1B1-AS1 61 -MAN1C1 2187 -MAN2A1 1627 -MAN2A2 4307 -MAN2B1 1624 -MAN2B2 2432 -MAN2C1 3209 -MANBA 1026 -MANBAL 1666 -MANEA 491 -MANEA-AS1 17 -MANEAL 1059 -MANF 4207 -MANSC1 539 -MANSC4 5 -MAOA 2886 -MAOB 8149 -MAP10 28 -MAP1A 33597 -MAP1B 81968 -MAP1LC3A 4046 -MAP1LC3B 5100 -MAP1LC3B2 312 -MAP1LC3C 40 -MAP1S 2483 -MAP2 29012 -MAP2K1 2567 -MAP2K2 4547 -MAP2K3 1209 -MAP2K4 2625 -MAP2K4P1 18 -MAP2K5 846 -MAP2K6 95 -MAP2K7 2445 -MAP3K1 596 -MAP3K10 4405 -MAP3K11 3376 -MAP3K12 1892 -MAP3K13 1920 -MAP3K14 929 -MAP3K14-AS1 75 -MAP3K15 172 -MAP3K19 305 -MAP3K2 2137 -MAP3K3 2240 -MAP3K4 1385 -MAP3K5 5569 -MAP3K6 1468 -MAP3K7 2047 -MAP3K7CL 155 -MAP3K8 302 -MAP3K9 2338 -MAP4 40182 -MAP4K1 199 -MAP4K2 1163 -MAP4K3 1314 -MAP4K4 16460 -MAP4K5 2210 -MAP6 5265 -MAP6D1 458 -MAP7 2269 -MAP7D1 11861 -MAP7D2 2297 -MAP7D3 744 -MAP9 3147 -MAPK1 6553 -MAPK10 4223 -MAPK11 1381 -MAPK12 628 -MAPK13 818 -MAPK14 1560 -MAPK15 0 -MAPK1IP1L 2457 -MAPK3 4822 -MAPK4 11063 -MAPK6 1058 -MAPK7 752 -MAPK8 1083 -MAPK8IP1 7246 -MAPK8IP2 9185 -MAPK8IP3 11942 -MAPK9 2648 -MAPKAP1 2867 -MAPKAPK2 3289 -MAPKAPK3 770 -MAPKAPK5 489 -MAPKAPK5-AS1 580 -MAPKBP1 3105 -MAPRE1 2283 -MAPRE2 5225 -MAPRE3 7645 -MAPT 1017 -MAPT-AS1 2 -MAPT-IT1 11 -MARC1 1632 -MARC2 311 -MARCH1 846 -MARCH10 87 -MARCH11 87 -MARCH2 1728 -MARCH3 751 -MARCH4 390 -MARCH5 1152 -MARCH6 8872 -MARCH7 979 -MARCH8 97 -MARCH9 982 -MARCKS 9973 -MARCKSL1 4752 -MARCO 134 -MARK1 1327 -MARK2 3694 -MARK2P9 15 -MARK3 3440 -MARK4 3009 -MARS 4759 -MARS2 150 -MARVELD1 633 -MARVELD2 2 -MARVELD3 57 -MAS1 0 -MAS1L 0 -MASP1 1298 -MASP2 74 -MAST1 5927 -MAST2 3967 -MAST3 3700 -MAST4 3031 -MASTL 281 -MAT1A 51 -MAT2A 5907 -MAT2B 1998 -MATK 647 -MATN1 10 -MATN1-AS1 27 -MATN2 1989 -MATN3 112 -MATN4 6 -MATR3 9838 -MAU2 2362 -MAVS 6576 -MAX 3002 -MAZ 6273 -MB 2 -MB21D1 631 -MB21D2 176 -MBD1 2450 -MBD2 2035 -MBD3 4132 -MBD3L1 0 -MBD3L2 0 -MBD3L3 0 -MBD3L4 0 -MBD3L5 0 -MBD4 770 -MBD5 705 -MBD6 3212 -MBIP 871 -MBL1P 23 -MBL2 1 -MBLAC1 101 -MBLAC2 379 -MBNL1 3402 -MBNL1-AS1 78 -MBNL2 5394 -MBNL3 268 -MBOAT1 159 -MBOAT2 1603 -MBOAT4 10 -MBOAT7 3 -MBP 115190 -MBTD1 656 -MBTPS1 4172 -MBTPS2 361 -MC1R 951 -MC2R 0 -MC3R 522 -MC4R 51 -MC5R 1 -MCAM 3197 -MCAT 440 -MCC 1298 -MCCC1 897 -MCCC2 1110 -MCCD1 0 -MCEE 145 -MCEMP1 9 -MCF2 418 -MCF2L 5364 -MCF2L-AS1 63 -MCF2L2 1199 -MCFD2 5306 -MCHR1 249 -MCHR2 5 -MCHR2-AS1 0 -MCIDAS 13 -MCL1 16978 -MCM10 13 -MCM2 147 -MCM3 624 -MCM3AP 2860 -MCM3AP-AS1 380 -MCM4 528 -MCM5 292 -MCM6 329 -MCM7 1735 -MCM8 296 -MCM8-AS1 4 -MCM9 356 -MCMBP 1293 -MCMDC2 129 -MCOLN1 817 -MCOLN2 18 -MCOLN3 192 -MCPH1 521 -MCPH1-AS1 228 -MCRS1 1209 -MCTP1 529 -MCTP2 291 -MCTS1 1601 -MCTS2P 71 -MCU 798 -MCUR1 1728 -MDC1 3 -MDFI 233 -MDFIC 1243 -MDGA1 1407 -MDGA2 637 -MDH1 4995 -MDH1B 222 -MDH2 3202 -MDK 1440 -MDM1 684 -MDM2 1866 -MDM4 3613 -MDN1 3541 -MDP1 30 -MDS2 0 -ME1 1318 -ME2 1757 -ME3 889 -MEA1 1850 -MEAF6 2922 -MEAT6 34 -MECOM 723 -MECP2 6541 -MECR 427 -MED1 1962 -MED10 842 -MED11 331 -MED12 2767 -MED12L 773 -MED13 2956 -MED13L 3920 -MED14 950 -MED14OS 20 -MED15 3593 -MED15P9 0 -MED16 921 -MED17 800 -MED18 404 -MED19 611 -MED20 402 -MED21 1195 -MED22 1044 -MED23 860 -MED24 2471 -MED25 2209 -MED26 802 -MED27 430 -MED28 1116 -MED29 2367 -MED30 244 -MED31 137 -MED4 731 -MED4-AS1 1 -MED6 510 -MED7 267 -MED8 985 -MED9 740 -MEDAG 130 -MEF2A 2659 -MEF2B 0 -MEF2BNB 930 -MEF2BNB-MEF2B 9 -MEF2C 1636 -MEF2C-AS1 23 -MEF2D 4119 -MEFV 69 -MEG3 72741 -MEG8 89 -MEG9 635 -MEGF10 2180 -MEGF11 324 -MEGF6 253 -MEGF8 7128 -MEGF9 4040 -MEI1 27 -MEI4 13 -MEIG1 31 -MEIKIN 25 -MEIOB 7 -MEIS1 119 -MEIS1-AS2 2 -MEIS1-AS3 2 -MEIS2 946 -MEIS3 1681 -MEIS3P1 306 -MELK 6 -MEMO1 276 -MEN1 1379 -MEOX1 2 -MEOX2 96 -MEOX2-AS1 37 -MEP1A 0 -MEP1B 4 -MEPCE 2292 -MEPE 7 -MERTK 1742 -MESDC1 747 -MESDC2 2344 -MESP1 292 -MESP2 17 -MEST 3389 -MESTIT1 64 -MET 290 -METAP1 649 -METAP1D 109 -METAP2 4892 -METRN 4252 -METRNL 134 -METTL1 129 -METTL10 309 -METTL11B 2 -METTL12 107 -METTL13 708 -METTL14 653 -METTL15 230 -METTL16 2062 -METTL17 617 -METTL18 162 -METTL20 178 -METTL21A 670 -METTL21B 107 -METTL21C 0 -METTL21EP 15 -METTL22 271 -METTL23 364 -METTL24 61 -METTL25 90 -METTL2A 361 -METTL2B 353 -METTL3 846 -METTL4 456 -METTL5 771 -METTL6 419 -METTL7A 9666 -METTL7B 276 -METTL8 551 -METTL9 2988 -MEX3A 508 -MEX3B 187 -MEX3C 1116 -MEX3D 861 -MFAP1 1388 -MFAP2 84 -MFAP3 1137 -MFAP3L 1759 -MFAP4 962 -MFAP5 368 -MFF 2871 -MFGE8 3604 -MFHAS1 835 -MFI2 304 -MFI2-AS1 568 -MFN1 671 -MFN2 5294 -MFNG 189 -MFRP 0 -MFSD1 1037 -MFSD10 2044 -MFSD11 767 -MFSD12 980 -MFSD2A 1395 -MFSD2B 8 -MFSD3 627 -MFSD4 567 -MFSD5 488 -MFSD6 2523 -MFSD6L 12 -MFSD7 205 -MFSD8 367 -MFSD9 125 -MGA 1642 -MGAM 2 -MGAM2 0 -MGARP 239 -MGAT1 3591 -MGAT2 546 -MGAT3 2249 -MGAT3-AS1 22 -MGAT4A 1872 -MGAT4B 1946 -MGAT4C 74 -MGAT4D 0 -MGAT4EP 5 -MGAT5 3291 -MGAT5B 459 -MGC12916 7 -MGC15885 10 -MGC16025 39 -MGC16142 109 -MGC16275 161 -MGC27345 666 -MGC27382 0 -MGC2889 22 -MGC32805 1 -MGC34796 8 -MGC39584 0 -MGC45922 6 -MGC50722 61 -MGC57346 48 -MGC57346-CRHR1 0 -MGC70870 439 -MGC72080 69 -MGEA5 8172 -MGLL 2275 -MGME1 237 -MGMT 361 -MGP 3270 -MGRN1 4308 -MGST1 5357 -MGST2 723 -MGST3 2719 -MHRT 0 -MIA 40 -MIA-RAB4B 8 -MIA2 0 -MIA3 3650 -MIAT 9924 -MIATNB 34 -MIB1 2468 -MIB2 4364 -MICA 0 -MICAL1 2931 -MICAL2 1014 -MICAL3 5568 -MICALCL 4 -MICALL1 1216 -MICALL2 2230 -MICB 0 -MICU1 1879 -MICU2 1272 -MICU3 551 -MID1 2543 -MID1IP1 4305 -MID1IP1-AS1 34 -MID2 992 -MIDN 5006 -MIEF1 1386 -MIEF2 269 -MIEN1 1561 -MIER1 1901 -MIER2 1406 -MIER3 1016 -MIF 0 -MIF-AS1 0 -MIF4GD 252 -MIIP 665 -MILR1 98 -MIMT1 47 -MINA 770 -MINK1 6892 -MINOS1 2027 -MINOS1-NBL1 0 -MINOS1P1 123 -MINPP1 632 -MIOS 793 -MIOX 11 -MIP 12 -MIPEP 183 -MIPEPP3 103 -MIPOL1 268 -MIR1-1 0 -MIR1-1HG 0 -MIR1-2 0 -MIR100 0 -MIR100HG 4757 -MIR101-1 0 -MIR101-2 0 -MIR103A1 0 -MIR103A2 0 -MIR103B1 0 -MIR103B2 0 -MIR105-1 0 -MIR105-2 0 -MIR106A 0 -MIR106B 0 -MIR107 0 -MIR10A 0 -MIR10B 0 -MIR1178 0 -MIR1179 0 -MIR1180 0 -MIR1181 0 -MIR1182 0 -MIR1183 0 -MIR1184-1 0 -MIR1184-2 0 -MIR1184-3 0 -MIR1185-1 0 -MIR1185-2 1 -MIR1193 0 -MIR1197 0 -MIR1199 0 -MIR1200 0 -MIR1202 0 -MIR1203 0 -MIR1204 0 -MIR1205 0 -MIR1206 0 -MIR1207 0 -MIR1208 0 -MIR122 0 -MIR1224 3 -MIR1225 6 -MIR1226 0 -MIR1227 1 -MIR1228 0 -MIR1229 1 -MIR1231 0 -MIR1233-1 0 -MIR1233-2 0 -MIR1234 0 -MIR1236 0 -MIR1237 0 -MIR1238 0 -MIR124-1 0 -MIR124-2 0 -MIR124-2HG 93 -MIR124-3 0 -MIR1243 0 -MIR1244-1 0 -MIR1244-2 0 -MIR1244-3 0 -MIR1244-4 0 -MIR1245A 0 -MIR1245B 0 -MIR1246 0 -MIR1247 1 -MIR1248 0 -MIR1249 0 -MIR1250 0 -MIR1251 0 -MIR1252 0 -MIR1253 3 -MIR1254-1 3 -MIR1254-2 0 -MIR1255A 0 -MIR1255B1 0 -MIR1255B2 0 -MIR1256 0 -MIR1257 0 -MIR1258 0 -MIR125A 0 -MIR125B1 0 -MIR125B2 0 -MIR126 0 -MIR1260A 0 -MIR1260B 0 -MIR1261 0 -MIR1262 0 -MIR1263 0 -MIR1264 0 -MIR1265 0 -MIR1266 0 -MIR1267 0 -MIR1268A 0 -MIR1268B 0 -MIR1269A 0 -MIR1269B 0 -MIR127 0 -MIR1270 0 -MIR1271 0 -MIR1272 0 -MIR1273A 0 -MIR1273C 0 -MIR1273D 0 -MIR1273E 0 -MIR1273F 0 -MIR1273G 0 -MIR1273H 1 -MIR1275 0 -MIR1276 0 -MIR1277 0 -MIR1278 0 -MIR1279 0 -MIR128-1 0 -MIR128-2 0 -MIR1281 0 -MIR1282 0 -MIR1283-1 0 -MIR1283-2 0 -MIR1284 0 -MIR1285-1 0 -MIR1285-2 0 -MIR1286 0 -MIR1287 0 -MIR1288 0 -MIR1289-1 0 -MIR1289-2 0 -MIR129-1 0 -MIR129-2 0 -MIR1290 0 -MIR1291 0 -MIR1292 2 -MIR1293 0 -MIR1294 0 -MIR1295A 0 -MIR1295B 0 -MIR1296 0 -MIR1297 0 -MIR1298 0 -MIR1299 0 -MIR1301 2 -MIR1302-1 1 -MIR1302-10 0 -MIR1302-11 0 -MIR1302-2 0 -MIR1302-3 0 -MIR1302-4 0 -MIR1302-5 0 -MIR1302-6 0 -MIR1302-7 0 -MIR1302-8 2 -MIR1302-9 0 -MIR1303 0 -MIR1304 0 -MIR1305 0 -MIR1306 0 -MIR1307 0 -MIR130A 0 -MIR130B 1 -MIR132 2 -MIR1321 0 -MIR1322 0 -MIR1323 0 -MIR1324 1 -MIR133A1 0 -MIR133A1HG 7 -MIR133A2 0 -MIR133B 0 -MIR134 0 -MIR1343 0 -MIR135A1 0 -MIR135A2 0 -MIR135B 0 -MIR136 0 -MIR137 0 -MIR137HG 65 -MIR138-1 0 -MIR138-2 0 -MIR139 0 -MIR140 0 -MIR141 0 -MIR142 0 -MIR143 0 -MIR143HG 17 -MIR144 0 -MIR145 0 -MIR1468 0 -MIR1469 0 -MIR146A 0 -MIR146B 0 -MIR1470 0 -MIR1471 0 -MIR147A 0 -MIR147B 0 -MIR148A 0 -MIR148B 0 -MIR149 0 -MIR150 0 -MIR151A 0 -MIR151B 0 -MIR152 0 -MIR153-1 0 -MIR153-2 0 -MIR1537 0 -MIR1538 0 -MIR1539 0 -MIR154 0 -MIR155 0 -MIR155HG 33 -MIR1587 0 -MIR15A 0 -MIR15B 0 -MIR16-1 0 -MIR16-2 0 -MIR17 0 -MIR17HG 16 -MIR181A1 0 -MIR181A1HG 0 -MIR181A2 0 -MIR181A2HG 10 -MIR181B1 0 -MIR181B2 0 -MIR181C 0 -MIR181D 3 -MIR182 0 -MIR1825 0 -MIR1827 0 -MIR183 0 -MIR184 0 -MIR185 0 -MIR186 0 -MIR187 0 -MIR188 0 -MIR18A 0 -MIR18B 0 -MIR1908 1 -MIR1909 0 -MIR190A 0 -MIR190B 0 -MIR191 0 -MIR1910 0 -MIR1911 0 -MIR1912 0 -MIR1913 0 -MIR1914 1 -MIR1915 1 -MIR192 0 -MIR193A 1 -MIR193B 0 -MIR194-1 0 -MIR194-2 0 -MIR195 0 -MIR196A1 0 -MIR196A2 0 -MIR196B 0 -MIR197 0 -MIR1972-1 0 -MIR1972-2 0 -MIR1973 0 -MIR1976 0 -MIR198 0 -MIR199A1 1 -MIR199A2 0 -MIR199B 1 -MIR19A 0 -MIR19B1 0 -MIR19B2 0 -MIR200A 0 -MIR200B 0 -MIR200C 0 -MIR202 0 -MIR202HG 1 -MIR203A 0 -MIR203B 0 -MIR204 0 -MIR205 0 -MIR2052 0 -MIR2052HG 3 -MIR2053 0 -MIR2054 0 -MIR205HG 1 -MIR206 0 -MIR208A 0 -MIR208B 0 -MIR20A 0 -MIR20B 0 -MIR21 0 -MIR210 0 -MIR210HG 4 -MIR211 0 -MIR2110 0 -MIR2113 0 -MIR2114 0 -MIR2115 0 -MIR2116 0 -MIR2117 0 -MIR212 5 -MIR214 0 -MIR215 0 -MIR216A 0 -MIR216B 0 -MIR217 0 -MIR217HG 3 -MIR218-1 0 -MIR218-2 0 -MIR219A1 0 -MIR219A2 0 -MIR219B 0 -MIR22 0 -MIR221 0 -MIR222 0 -MIR223 0 -MIR224 0 -MIR2276 0 -MIR2277 0 -MIR2278 1 -MIR22HG 5 -MIR2355 0 -MIR2392 0 -MIR23A 1 -MIR23B 0 -MIR23C 1 -MIR24-1 0 -MIR24-2 0 -MIR2467 0 -MIR25 0 -MIR2681 0 -MIR2682 1 -MIR26A1 0 -MIR26A2 0 -MIR26B 0 -MIR27A 0 -MIR27B 1 -MIR28 0 -MIR2861 11 -MIR2909 0 -MIR296 0 -MIR297 0 -MIR298 0 -MIR299 0 -MIR29A 0 -MIR29B1 0 -MIR29B2 1 -MIR29C 10 -MIR300 0 -MIR301A 0 -MIR301B 0 -MIR302A 0 -MIR302B 1 -MIR302C 1 -MIR302D 1 -MIR302E 0 -MIR302F 0 -MIR3064 80 -MIR3065 0 -MIR3074 0 -MIR30A 0 -MIR30B 0 -MIR30C1 0 -MIR30C2 0 -MIR30D 0 -MIR30E 0 -MIR31 0 -MIR3115 0 -MIR3116-1 0 -MIR3116-2 0 -MIR3117 0 -MIR3118-1 0 -MIR3118-2 0 -MIR3118-3 0 -MIR3118-4 0 -MIR3119-1 0 -MIR3119-2 0 -MIR3120 0 -MIR3121 0 -MIR3122 0 -MIR3123 0 -MIR3124 0 -MIR3125 0 -MIR3126 0 -MIR3127 3 -MIR3128 0 -MIR3129 0 -MIR3130-1 0 -MIR3130-2 0 -MIR3131 0 -MIR3132 1 -MIR3133 0 -MIR3134 0 -MIR3135A 0 -MIR3135B 0 -MIR3136 0 -MIR3137 0 -MIR3138 0 -MIR3139 0 -MIR3140 0 -MIR3141 0 -MIR3142 0 -MIR3143 0 -MIR3144 0 -MIR3145 0 -MIR3146 0 -MIR3147 0 -MIR3148 0 -MIR3149 0 -MIR3150A 0 -MIR3150B 0 -MIR3151 0 -MIR3152 0 -MIR3153 0 -MIR3154 0 -MIR3155A 0 -MIR3155B 0 -MIR3156-1 0 -MIR3156-2 0 -MIR3156-3 0 -MIR3157 0 -MIR3158-1 0 -MIR3158-2 0 -MIR3159 0 -MIR3160-1 0 -MIR3160-2 0 -MIR3161 0 -MIR3162 0 -MIR3163 0 -MIR3164 0 -MIR3165 0 -MIR3166 0 -MIR3167 0 -MIR3168 0 -MIR3169 0 -MIR3170 0 -MIR3171 0 -MIR3173 0 -MIR3174 0 -MIR3175 0 -MIR3176 2 -MIR3177 0 -MIR3178 0 -MIR3179-1 0 -MIR3179-2 0 -MIR3179-3 0 -MIR3179-4 0 -MIR3180-1 0 -MIR3180-2 0 -MIR3180-3 0 -MIR3180-4 0 -MIR3180-5 0 -MIR3181 0 -MIR3182 0 -MIR3183 0 -MIR3184 0 -MIR3185 0 -MIR3186 1 -MIR3187 0 -MIR3188 2 -MIR3189 0 -MIR3190 0 -MIR3191 0 -MIR3192 0 -MIR3193 0 -MIR3194 0 -MIR3195 0 -MIR3196 0 -MIR3197 1 -MIR3198-1 0 -MIR3198-2 0 -MIR3199-1 0 -MIR3199-2 0 -MIR31HG 14 -MIR32 0 -MIR3200 0 -MIR3201 0 -MIR3202-1 0 -MIR3202-2 0 -MIR320A 0 -MIR320B1 0 -MIR320B2 0 -MIR320C1 2 -MIR320C2 0 -MIR320D1 0 -MIR320D2 0 -MIR320E 0 -MIR323A 0 -MIR323B 0 -MIR324 22 -MIR325 0 -MIR325HG 13 -MIR326 0 -MIR328 0 -MIR329-1 0 -MIR329-2 0 -MIR330 0 -MIR331 1 -MIR335 0 -MIR337 0 -MIR338 0 -MIR339 0 -MIR33A 0 -MIR33B 0 -MIR340 0 -MIR342 0 -MIR345 0 -MIR346 0 -MIR34A 0 -MIR34B 0 -MIR34C 0 -MIR3529 0 -MIR3591 0 -MIR3605 1 -MIR3606 0 -MIR3607 0 -MIR3609 1 -MIR361 0 -MIR3610 0 -MIR3611 0 -MIR3612 0 -MIR3613 1 -MIR3614 0 -MIR3615 0 -MIR3616 0 -MIR3617 0 -MIR3618 0 -MIR3619 0 -MIR362 0 -MIR3620 4 -MIR3621 0 -MIR3622A 0 -MIR3622B 0 -MIR363 0 -MIR3646 0 -MIR3648-1 0 -MIR3648-2 0 -MIR3649 0 -MIR3650 0 -MIR3651 0 -MIR3652 0 -MIR3653 1 -MIR3654 57 -MIR3655 0 -MIR3656 0 -MIR3657 0 -MIR3658 0 -MIR3659 0 -MIR365A 0 -MIR365B 0 -MIR3660 0 -MIR3661 0 -MIR3662 0 -MIR3663 0 -MIR3663HG 2 -MIR3664 0 -MIR3665 0 -MIR3666 0 -MIR3667 0 -MIR3668 0 -MIR367 0 -MIR3670-1 0 -MIR3670-2 0 -MIR3670-3 0 -MIR3670-4 0 -MIR3671 0 -MIR3672 0 -MIR3674 0 -MIR3675 0 -MIR3677 1 -MIR3678 0 -MIR3679 0 -MIR3680-1 0 -MIR3680-2 0 -MIR3681 0 -MIR3682 0 -MIR3683 0 -MIR3684 0 -MIR3685 1 -MIR3686 0 -MIR3687-1 0 -MIR3687-2 0 -MIR3688-1 0 -MIR3688-2 0 -MIR3689A 0 -MIR3689B 0 -MIR3689C 0 -MIR3689D1 0 -MIR3689D2 0 -MIR3689E 0 -MIR3689F 0 -MIR369 0 -MIR3690 0 -MIR3691 0 -MIR3692 0 -MIR370 0 -MIR3713 0 -MIR3714 0 -MIR371A 0 -MIR371B 0 -MIR372 0 -MIR373 0 -MIR374A 0 -MIR374B 0 -MIR374C 0 -MIR375 0 -MIR376A1 0 -MIR376A2 0 -MIR376B 0 -MIR376C 0 -MIR377 0 -MIR378A 0 -MIR378B 0 -MIR378C 0 -MIR378D1 0 -MIR378D2 0 -MIR378E 0 -MIR378F 0 -MIR378G 0 -MIR378H 4 -MIR378I 0 -MIR378J 0 -MIR379 0 -MIR380 0 -MIR381 0 -MIR381HG 6 -MIR382 0 -MIR383 0 -MIR384 0 -MIR3907 0 -MIR3908 0 -MIR3909 2 -MIR3910-1 0 -MIR3910-2 0 -MIR3911 15 -MIR3912 0 -MIR3913-1 0 -MIR3913-2 0 -MIR3914-1 0 -MIR3914-2 0 -MIR3915 0 -MIR3916 4 -MIR3917 0 -MIR3918 0 -MIR3919 0 -MIR3920 0 -MIR3921 0 -MIR3922 0 -MIR3923 0 -MIR3924 0 -MIR3925 0 -MIR3926-1 0 -MIR3926-2 0 -MIR3927 0 -MIR3928 2 -MIR3929 0 -MIR3934 3 -MIR3935 0 -MIR3936 24 -MIR3937 0 -MIR3938 0 -MIR3939 0 -MIR3940 0 -MIR3941 0 -MIR3942 2 -MIR3943 0 -MIR3944 0 -MIR3945 0 -MIR3960 6 -MIR3972 0 -MIR3973 0 -MIR3974 0 -MIR3975 0 -MIR3976 0 -MIR3976HG 0 -MIR3977 1 -MIR3978 0 -MIR409 0 -MIR410 0 -MIR411 0 -MIR412 0 -MIR421 0 -MIR422A 0 -MIR423 0 -MIR424 0 -MIR425 1 -MIR4251 0 -MIR4252 0 -MIR4253 0 -MIR4254 0 -MIR4255 0 -MIR4256 0 -MIR4257 4 -MIR4258 2 -MIR4259 0 -MIR4260 0 -MIR4261 0 -MIR4262 0 -MIR4263 1 -MIR4264 0 -MIR4265 1 -MIR4266 0 -MIR4267 0 -MIR4268 0 -MIR4269 0 -MIR4270 2 -MIR4271 2 -MIR4272 0 -MIR4273 0 -MIR4274 0 -MIR4275 0 -MIR4276 0 -MIR4277 0 -MIR4278 0 -MIR4279 0 -MIR4280 0 -MIR4281 0 -MIR4282 0 -MIR4283-1 0 -MIR4283-2 0 -MIR4284 0 -MIR4285 1 -MIR4286 0 -MIR4287 0 -MIR4288 0 -MIR4289 0 -MIR429 0 -MIR4290 0 -MIR4291 0 -MIR4292 2 -MIR4293 0 -MIR4294 0 -MIR4295 0 -MIR4296 0 -MIR4297 0 -MIR4298 0 -MIR4299 0 -MIR4300 0 -MIR4301 0 -MIR4302 0 -MIR4303 0 -MIR4304 0 -MIR4305 0 -MIR4306 0 -MIR4307 0 -MIR4308 0 -MIR4309 0 -MIR431 0 -MIR4310 0 -MIR4311 0 -MIR4312 0 -MIR4313 2 -MIR4314 0 -MIR4315-1 0 -MIR4315-2 0 -MIR4316 0 -MIR4317 0 -MIR4318 0 -MIR4319 1 -MIR432 0 -MIR4320 0 -MIR4321 5 -MIR4322 0 -MIR4323 0 -MIR4324 1 -MIR4325 0 -MIR4326 0 -MIR4327 0 -MIR4328 0 -MIR4329 0 -MIR433 0 -MIR4330 0 -MIR4417 0 -MIR4418 0 -MIR4419A 0 -MIR4419B 0 -MIR4420 0 -MIR4421 0 -MIR4422 0 -MIR4423 0 -MIR4424 0 -MIR4425 0 -MIR4426 0 -MIR4427 0 -MIR4428 1 -MIR4429 0 -MIR4430 0 -MIR4431 0 -MIR4432 0 -MIR4433A 0 -MIR4433B 0 -MIR4434 0 -MIR4435-1 0 -MIR4435-2 0 -MIR4435-2HG 34 -MIR4436A 0 -MIR4436B1 0 -MIR4436B2 0 -MIR4437 0 -MIR4438 0 -MIR4439 0 -MIR4440 0 -MIR4441 1 -MIR4442 0 -MIR4443 0 -MIR4444-1 0 -MIR4444-2 0 -MIR4445 0 -MIR4446 0 -MIR4447 0 -MIR4448 0 -MIR4449 2 -MIR4450 0 -MIR4451 1 -MIR4452 0 -MIR4453 0 -MIR4454 0 -MIR4455 0 -MIR4456 0 -MIR4457 0 -MIR4458 0 -MIR4458HG 256 -MIR4459 0 -MIR4460 0 -MIR4461 12 -MIR4462 0 -MIR4463 0 -MIR4464 0 -MIR4465 0 -MIR4466 0 -MIR4467 2 -MIR4468 0 -MIR4469 0 -MIR4470 0 -MIR4471 0 -MIR4472-1 0 -MIR4472-2 0 -MIR4473 1 -MIR4474 0 -MIR4475 0 -MIR4476 0 -MIR4477A 0 -MIR4477B 0 -MIR4478 0 -MIR4479 0 -MIR448 0 -MIR4480 0 -MIR4481 0 -MIR4482 0 -MIR4483 0 -MIR4484 0 -MIR4485 0 -MIR4486 0 -MIR4487 0 -MIR4488 0 -MIR4489 5 -MIR4490 0 -MIR4491 0 -MIR4492 0 -MIR4493 0 -MIR4494 0 -MIR4495 0 -MIR4496 1 -MIR4497 0 -MIR4498 0 -MIR4499 0 -MIR449A 0 -MIR449B 0 -MIR449C 0 -MIR4500 0 -MIR4500HG 4 -MIR4501 0 -MIR4502 2 -MIR4503 0 -MIR4504 0 -MIR4505 0 -MIR4506 0 -MIR4507 0 -MIR4508 0 -MIR4509-1 0 -MIR4509-2 0 -MIR4509-3 0 -MIR450A1 0 -MIR450A2 0 -MIR450B 0 -MIR4510 0 -MIR4511 0 -MIR4512 0 -MIR4513 0 -MIR4514 0 -MIR4515 0 -MIR4516 0 -MIR4517 0 -MIR4518 0 -MIR4519 0 -MIR451A 0 -MIR451B 0 -MIR452 0 -MIR4520-1 0 -MIR4520-2 0 -MIR4521 0 -MIR4522 0 -MIR4523 1 -MIR4524A 0 -MIR4524B 0 -MIR4525 0 -MIR4526 0 -MIR4527 0 -MIR4528 0 -MIR4529 0 -MIR4530 0 -MIR4531 0 -MIR4532 0 -MIR4533 0 -MIR4534 0 -MIR4535 0 -MIR4536-1 0 -MIR4536-2 0 -MIR4537 0 -MIR4538 0 -MIR4539 0 -MIR454 0 -MIR4540 0 -MIR455 0 -MIR4632 0 -MIR4633 0 -MIR4634 0 -MIR4635 0 -MIR4636 0 -MIR4637 0 -MIR4638 0 -MIR4639 0 -MIR4640 0 -MIR4641 0 -MIR4642 0 -MIR4643 0 -MIR4644 0 -MIR4645 0 -MIR4646 0 -MIR4647 0 -MIR4648 1 -MIR4649 12 -MIR4650-1 0 -MIR4650-2 0 -MIR4651 0 -MIR4652 0 -MIR4653 0 -MIR4654 0 -MIR4655 0 -MIR4656 0 -MIR4657 0 -MIR4658 0 -MIR4659A 0 -MIR4659B 0 -MIR466 0 -MIR4660 0 -MIR4661 0 -MIR4662A 0 -MIR4662B 0 -MIR4663 0 -MIR4664 0 -MIR4665 0 -MIR4666A 0 -MIR4666B 0 -MIR4667 0 -MIR4668 0 -MIR4669 0 -MIR4670 0 -MIR4671 0 -MIR4672 1 -MIR4673 0 -MIR4674 0 -MIR4675 0 -MIR4676 0 -MIR4677 0 -MIR4678 0 -MIR4679-1 0 -MIR4679-2 0 -MIR4680 0 -MIR4681 0 -MIR4682 0 -MIR4683 0 -MIR4684 0 -MIR4685 0 -MIR4686 0 -MIR4687 0 -MIR4688 0 -MIR4689 0 -MIR4690 0 -MIR4691 0 -MIR4692 0 -MIR4693 0 -MIR4694 0 -MIR4695 0 -MIR4696 0 -MIR4697 0 -MIR4697HG 1743 -MIR4698 0 -MIR4699 0 -MIR4700 0 -MIR4701 0 -MIR4703 0 -MIR4704 0 -MIR4705 0 -MIR4706 0 -MIR4707 0 -MIR4708 0 -MIR4709 0 -MIR4710 0 -MIR4711 0 -MIR4712 0 -MIR4713 0 -MIR4714 0 -MIR4715 0 -MIR4716 0 -MIR4717 0 -MIR4718 0 -MIR4719 0 -MIR4720 0 -MIR4721 13 -MIR4722 0 -MIR4723 0 -MIR4724 0 -MIR4725 0 -MIR4726 0 -MIR4727 0 -MIR4728 2 -MIR4729 0 -MIR4730 0 -MIR4731 0 -MIR4732 0 -MIR4733 0 -MIR4734 0 -MIR4735 0 -MIR4736 0 -MIR4737 1 -MIR4738 0 -MIR4739 0 -MIR4740 0 -MIR4741 0 -MIR4742 0 -MIR4743 0 -MIR4744 1 -MIR4745 0 -MIR4746 2 -MIR4747 0 -MIR4748 1 -MIR4749 0 -MIR4750 0 -MIR4751 0 -MIR4752 0 -MIR4753 0 -MIR4754 0 -MIR4755 0 -MIR4756 0 -MIR4757 0 -MIR4758 0 -MIR4759 0 -MIR4760 0 -MIR4761 1 -MIR4762 0 -MIR4763 0 -MIR4764 0 -MIR4765 0 -MIR4766 0 -MIR4767 1 -MIR4768 3 -MIR4769 0 -MIR4770 0 -MIR4771-1 0 -MIR4771-2 0 -MIR4772 0 -MIR4773-1 0 -MIR4773-2 0 -MIR4774 0 -MIR4775 0 -MIR4776-1 0 -MIR4776-2 0 -MIR4777 0 -MIR4778 0 -MIR4779 0 -MIR4780 0 -MIR4781 0 -MIR4782 0 -MIR4783 0 -MIR4784 7 -MIR4785 0 -MIR4786 0 -MIR4787 2 -MIR4788 0 -MIR4789 0 -MIR4790 0 -MIR4791 0 -MIR4792 0 -MIR4793 0 -MIR4794 0 -MIR4795 0 -MIR4796 0 -MIR4797 0 -MIR4798 0 -MIR4799 0 -MIR4800 0 -MIR4801 0 -MIR4802 0 -MIR4803 0 -MIR4804 0 -MIR483 0 -MIR484 0 -MIR485 0 -MIR486-1 0 -MIR486-2 0 -MIR487A 0 -MIR487B 0 -MIR488 0 -MIR489 0 -MIR490 0 -MIR491 0 -MIR492 1 -MIR493 1 -MIR494 0 -MIR495 0 -MIR496 0 -MIR497 0 -MIR497HG 320 -MIR498 0 -MIR4999 0 -MIR499A 4 -MIR499B 0 -MIR5000 0 -MIR5001 0 -MIR5002 0 -MIR5003 0 -MIR5004 0 -MIR5006 0 -MIR5007 0 -MIR5008 0 -MIR5009 0 -MIR500A 0 -MIR500B 0 -MIR501 0 -MIR5010 4 -MIR5011 0 -MIR502 0 -MIR503 0 -MIR503HG 39 -MIR504 0 -MIR5047 294 -MIR505 0 -MIR506 0 -MIR507 0 -MIR508 0 -MIR5087 4 -MIR5088 0 -MIR5089 0 -MIR509-1 0 -MIR509-2 0 -MIR509-3 0 -MIR5090 1 -MIR5091 0 -MIR5092 0 -MIR5093 0 -MIR5094 0 -MIR5095 0 -MIR5096 3 -MIR510 0 -MIR5100 0 -MIR511 0 -MIR512-1 0 -MIR512-2 0 -MIR513A1 0 -MIR513A2 0 -MIR513B 0 -MIR513C 0 -MIR514A1 0 -MIR514A2 0 -MIR514A3 0 -MIR514B 0 -MIR515-1 0 -MIR515-2 0 -MIR516A1 0 -MIR516A2 0 -MIR516B1 0 -MIR516B2 0 -MIR517A 0 -MIR517B 0 -MIR517C 0 -MIR5186 0 -MIR5187 0 -MIR5188 1 -MIR5189 0 -MIR518A1 0 -MIR518A2 0 -MIR518B 0 -MIR518C 0 -MIR518D 0 -MIR518E 0 -MIR518F 0 -MIR5190 1 -MIR5191 0 -MIR5192 1 -MIR5193 8 -MIR5194 0 -MIR5195 0 -MIR5196 1 -MIR5197 0 -MIR519A1 0 -MIR519A2 0 -MIR519B 0 -MIR519C 0 -MIR519D 0 -MIR519E 0 -MIR520A 0 -MIR520B 0 -MIR520C 0 -MIR520D 0 -MIR520E 0 -MIR520F 0 -MIR520G 0 -MIR520H 0 -MIR521-1 0 -MIR521-2 0 -MIR522 0 -MIR523 0 -MIR524 0 -MIR525 0 -MIR526A1 0 -MIR526A2 0 -MIR526B 0 -MIR527 0 -MIR532 0 -MIR539 0 -MIR541 0 -MIR542 0 -MIR543 0 -MIR544A 0 -MIR544B 0 -MIR545 0 -MIR548A1 0 -MIR548A2 0 -MIR548A3 0 -MIR548AA1 0 -MIR548AA2 0 -MIR548AB 0 -MIR548AC 0 -MIR548AD 0 -MIR548AE1 0 -MIR548AE2 0 -MIR548AG1 0 -MIR548AG2 0 -MIR548AH 0 -MIR548AI 0 -MIR548AJ1 0 -MIR548AJ2 0 -MIR548AK 0 -MIR548AL 0 -MIR548AM 0 -MIR548AN 0 -MIR548AO 0 -MIR548AP 0 -MIR548AQ 0 -MIR548AR 0 -MIR548AS 0 -MIR548AT 0 -MIR548AU 0 -MIR548AV 0 -MIR548AW 0 -MIR548AX 0 -MIR548AY 0 -MIR548AZ 0 -MIR548B 0 -MIR548BA 0 -MIR548BB 0 -MIR548C 0 -MIR548D1 0 -MIR548D2 0 -MIR548E 0 -MIR548F1 0 -MIR548F2 0 -MIR548F3 0 -MIR548F4 0 -MIR548F5 0 -MIR548G 0 -MIR548H1 0 -MIR548H2 0 -MIR548H3 0 -MIR548H4 0 -MIR548H5 0 -MIR548I1 0 -MIR548I2 1 -MIR548I3 0 -MIR548I4 0 -MIR548J 0 -MIR548K 0 -MIR548L 0 -MIR548M 0 -MIR548N 1 -MIR548O 0 -MIR548O2 0 -MIR548P 0 -MIR548Q 0 -MIR548S 0 -MIR548T 0 -MIR548U 0 -MIR548V 0 -MIR548W 0 -MIR548X 0 -MIR548X2 0 -MIR548Y 0 -MIR548Z 0 -MIR549A 0 -MIR550A1 0 -MIR550A2 0 -MIR550A3 0 -MIR550B1 0 -MIR550B2 0 -MIR551A 0 -MIR551B 0 -MIR552 0 -MIR553 0 -MIR554 0 -MIR555 6 -MIR556 0 -MIR557 0 -MIR5571 0 -MIR5572 2 -MIR5579 0 -MIR558 0 -MIR5580 0 -MIR5581 0 -MIR5582 0 -MIR5583-1 0 -MIR5583-2 0 -MIR5584 0 -MIR5585 0 -MIR5586 0 -MIR5587 0 -MIR5588 0 -MIR5589 0 -MIR559 0 -MIR5590 0 -MIR5591 0 -MIR561 0 -MIR562 0 -MIR563 0 -MIR564 1 -MIR566 0 -MIR567 0 -MIR568 0 -MIR5680 0 -MIR5681A 0 -MIR5681B 0 -MIR5682 0 -MIR5683 0 -MIR5684 0 -MIR5685 0 -MIR5687 0 -MIR5688 0 -MIR5689 0 -MIR569 1 -MIR5690 0 -MIR5691 0 -MIR5692A1 0 -MIR5692A2 0 -MIR5692B 0 -MIR5692C1 0 -MIR5692C2 0 -MIR5693 0 -MIR5694 0 -MIR5695 1 -MIR5696 0 -MIR5697 0 -MIR5698 0 -MIR5699 0 -MIR570 0 -MIR5700 0 -MIR5701-1 0 -MIR5701-2 0 -MIR5701-3 0 -MIR5702 0 -MIR5703 0 -MIR5704 0 -MIR5705 0 -MIR5706 0 -MIR5707 0 -MIR5708 0 -MIR571 0 -MIR572 0 -MIR573 0 -MIR5739 0 -MIR574 0 -MIR575 0 -MIR576 0 -MIR577 0 -MIR578 0 -MIR5787 0 -MIR579 0 -MIR580 0 -MIR581 0 -MIR582 0 -MIR583 0 -MIR584 0 -MIR585 0 -MIR586 0 -MIR587 0 -MIR588 0 -MIR589 0 -MIR590 0 -MIR591 0 -MIR592 0 -MIR593 1 -MIR595 0 -MIR596 0 -MIR597 2 -MIR598 0 -MIR599 0 -MIR600 0 -MIR600HG 850 -MIR601 0 -MIR602 1 -MIR603 0 -MIR604 2 -MIR605 0 -MIR606 0 -MIR6068 0 -MIR6069 0 -MIR607 0 -MIR6070 0 -MIR6071 8 -MIR6072 0 -MIR6073 0 -MIR6074 0 -MIR6075 0 -MIR6076 0 -MIR6077 0 -MIR6078 0 -MIR6079 0 -MIR608 0 -MIR6080 0 -MIR6081 0 -MIR6082 0 -MIR6083 0 -MIR6084 0 -MIR6085 0 -MIR6086 0 -MIR6087 0 -MIR6088 0 -MIR6089 0 -MIR609 0 -MIR6090 0 -MIR610 0 -MIR611 0 -MIR612 0 -MIR6124 0 -MIR6125 0 -MIR6126 3 -MIR6127 0 -MIR6128 0 -MIR6129 0 -MIR613 0 -MIR6130 0 -MIR6131 0 -MIR6132 0 -MIR6133 0 -MIR6134 0 -MIR614 0 -MIR615 0 -MIR616 2 -MIR6165 0 -MIR617 0 -MIR618 1 -MIR619 0 -MIR620 1 -MIR621 0 -MIR622 0 -MIR623 0 -MIR624 0 -MIR625 0 -MIR626 0 -MIR627 0 -MIR628 0 -MIR629 0 -MIR630 0 -MIR631 7 -MIR632 0 -MIR633 0 -MIR634 0 -MIR635 1 -MIR636 0 -MIR637 10 -MIR638 1 -MIR639 0 -MIR640 0 -MIR641 2 -MIR642A 0 -MIR642B 0 -MIR643 0 -MIR644A 0 -MIR645 0 -MIR646 0 -MIR646HG 23 -MIR647 6 -MIR648 0 -MIR649 0 -MIR6499 0 -MIR650 0 -MIR6500 0 -MIR6501 0 -MIR6502 0 -MIR6503 0 -MIR6504 0 -MIR6505 0 -MIR6506 0 -MIR6507 0 -MIR6508 0 -MIR6509 0 -MIR651 0 -MIR6510 0 -MIR6511A1 0 -MIR6511A2 0 -MIR6511A3 0 -MIR6511A4 0 -MIR6511B1 0 -MIR6511B2 0 -MIR6512 0 -MIR6513 0 -MIR6514 0 -MIR6515 1 -MIR6516 0 -MIR652 0 -MIR653 0 -MIR654 0 -MIR655 0 -MIR656 0 -MIR657 1 -MIR658 0 -MIR659 1 -MIR660 0 -MIR661 0 -MIR662 0 -MIR663A 5 -MIR663AHG 0 -MIR663B 0 -MIR664A 0 -MIR664B 0 -MIR665 0 -MIR668 0 -MIR670 0 -MIR670HG 2 -MIR671 0 -MIR6715A 0 -MIR6715B 0 -MIR6716 1 -MIR6717 2 -MIR6718 0 -MIR6719 0 -MIR6720 0 -MIR6721 0 -MIR6722 0 -MIR6723 0 -MIR6724-1 0 -MIR6724-2 0 -MIR6724-3 0 -MIR6724-4 0 -MIR6726 0 -MIR6727 0 -MIR6728 1 -MIR6729 0 -MIR6730 1 -MIR6731 0 -MIR6732 0 -MIR6733 0 -MIR6734 3 -MIR6735 0 -MIR6736 0 -MIR6737 0 -MIR6738 0 -MIR6739 1 -MIR6740 3 -MIR6741 2 -MIR6742 0 -MIR6743 0 -MIR6744 0 -MIR6745 0 -MIR6746 0 -MIR6747 0 -MIR6748 3 -MIR6749 0 -MIR675 0 -MIR6750 0 -MIR6751 4 -MIR6752 0 -MIR6753 2 -MIR6754 0 -MIR6755 1 -MIR6756 1 -MIR6757 1 -MIR6758 5 -MIR6759 2 -MIR676 0 -MIR6760 0 -MIR6761 1 -MIR6762 0 -MIR6763 0 -MIR6764 0 -MIR6765 0 -MIR6766 0 -MIR6767 0 -MIR6768 0 -MIR6769A 0 -MIR6769B 0 -MIR6770-1 0 -MIR6770-2 0 -MIR6770-3 0 -MIR6771 0 -MIR6772 0 -MIR6773 0 -MIR6774 3 -MIR6775 9 -MIR6776 0 -MIR6777 1 -MIR6778 0 -MIR6779 0 -MIR6780A 0 -MIR6780B 0 -MIR6781 0 -MIR6782 0 -MIR6783 0 -MIR6784 2 -MIR6785 2 -MIR6786 0 -MIR6787 0 -MIR6788 0 -MIR6789 4 -MIR6790 0 -MIR6791 0 -MIR6792 0 -MIR6793 1 -MIR6794 0 -MIR6795 0 -MIR6796 0 -MIR6797 1 -MIR6798 0 -MIR6799 0 -MIR6800 0 -MIR6801 0 -MIR6802 1 -MIR6803 0 -MIR6804 0 -MIR6805 0 -MIR6806 1 -MIR6807 8 -MIR6808 0 -MIR6809 0 -MIR6810 0 -MIR6811 0 -MIR6812 1 -MIR6813 0 -MIR6814 0 -MIR6815 0 -MIR6816 0 -MIR6817 0 -MIR6818 0 -MIR6819 5 -MIR6820 0 -MIR6821 2 -MIR6822 0 -MIR6823 0 -MIR6824 0 -MIR6825 0 -MIR6826 0 -MIR6827 0 -MIR6828 0 -MIR6829 1 -MIR6830 0 -MIR6831 0 -MIR6832 0 -MIR6833 0 -MIR6834 0 -MIR6835 0 -MIR6836 0 -MIR6837 0 -MIR6838 0 -MIR6839 0 -MIR6840 1 -MIR6841 0 -MIR6842 0 -MIR6843 38 -MIR6844 0 -MIR6845 3 -MIR6846 0 -MIR6847 2 -MIR6848 0 -MIR6849 0 -MIR6850 0 -MIR6851 0 -MIR6852 0 -MIR6853 0 -MIR6854 0 -MIR6855 3 -MIR6856 0 -MIR6857 0 -MIR6858 0 -MIR6859-1 0 -MIR6859-2 0 -MIR6859-3 0 -MIR6859-4 0 -MIR6860 0 -MIR6861 1 -MIR6862-1 0 -MIR6862-2 0 -MIR6863 0 -MIR6864 1 -MIR6865 2 -MIR6866 0 -MIR6867 2 -MIR6868 0 -MIR6869 1 -MIR6870 0 -MIR6871 0 -MIR6872 0 -MIR6873 0 -MIR6874 0 -MIR6875 0 -MIR6876 0 -MIR6877 0 -MIR6878 2 -MIR6879 0 -MIR6880 1 -MIR6881 0 -MIR6882 2 -MIR6883 8 -MIR6884 0 -MIR6885 0 -MIR6886 0 -MIR6887 0 -MIR6888 1 -MIR6889 0 -MIR6890 0 -MIR6891 0 -MIR6892 1 -MIR6893 0 -MIR6894 0 -MIR6895 3 -MIR7-1 1 -MIR7-2 0 -MIR7-3 0 -MIR7-3HG 618 -MIR708 0 -MIR7106 0 -MIR7107 0 -MIR7108 1 -MIR7109 0 -MIR711 0 -MIR7110 3 -MIR7111 3 -MIR7112 0 -MIR7113 1 -MIR7114 1 -MIR7150 0 -MIR7151 0 -MIR7152 0 -MIR7153 0 -MIR7154 0 -MIR7155 0 -MIR7156 0 -MIR7157 0 -MIR7158 0 -MIR7159 0 -MIR7160 0 -MIR7161 0 -MIR7162 0 -MIR718 0 -MIR744 0 -MIR7515 0 -MIR7515HG 0 -MIR758 0 -MIR759 0 -MIR760 0 -MIR761 0 -MIR762 0 -MIR762HG 147 -MIR764 0 -MIR7641-1 0 -MIR7641-2 0 -MIR765 4 -MIR766 0 -MIR767 0 -MIR769 0 -MIR770 0 -MIR7702 0 -MIR7703 0 -MIR7704 0 -MIR7705 0 -MIR7706 0 -MIR7843 0 -MIR7844 0 -MIR7845 0 -MIR7846 0 -MIR7847 1 -MIR7848 0 -MIR7849 0 -MIR7850 0 -MIR7851 0 -MIR7852 0 -MIR7853 0 -MIR7854 0 -MIR7855 0 -MIR7856 0 -MIR7973-1 0 -MIR7973-2 0 -MIR7974 0 -MIR7975 0 -MIR7976 0 -MIR7977 0 -MIR7978 0 -MIR802 0 -MIR8052 0 -MIR8053 0 -MIR8054 0 -MIR8055 1 -MIR8056 0 -MIR8057 0 -MIR8058 0 -MIR8059 0 -MIR8060 0 -MIR8061 0 -MIR8062 0 -MIR8063 0 -MIR8064 1 -MIR8065 0 -MIR8066 1 -MIR8067 0 -MIR8068 0 -MIR8069-1 0 -MIR8069-2 0 -MIR8070 0 -MIR8071-1 0 -MIR8071-2 0 -MIR8072 0 -MIR8073 0 -MIR8074 0 -MIR8075 0 -MIR8076 0 -MIR8077 0 -MIR8078 0 -MIR8079 0 -MIR8080 0 -MIR8081 0 -MIR8082 0 -MIR8083 1 -MIR8084 0 -MIR8085 0 -MIR8086 0 -MIR8087 0 -MIR8088 0 -MIR8089 1 -MIR8485 0 -MIR873 0 -MIR874 0 -MIR875 0 -MIR876 0 -MIR877 0 -MIR885 0 -MIR887 0 -MIR888 0 -MIR889 0 -MIR890 0 -MIR891A 0 -MIR891B 0 -MIR892A 0 -MIR892B 0 -MIR892C 0 -MIR9-1 0 -MIR9-2 0 -MIR9-3 0 -MIR920 0 -MIR921 0 -MIR922 0 -MIR924 0 -MIR92A1 0 -MIR92A2 0 -MIR92B 0 -MIR93 0 -MIR933 0 -MIR934 0 -MIR935 0 -MIR936 0 -MIR937 0 -MIR938 0 -MIR939 3 -MIR940 0 -MIR941-1 0 -MIR941-2 0 -MIR941-3 0 -MIR941-4 0 -MIR941-5 0 -MIR942 0 -MIR943 0 -MIR944 0 -MIR95 0 -MIR9500 0 -MIR96 0 -MIR98 0 -MIR99A 0 -MIR99AHG 495 -MIR99B 2 -MIRLET7A1 0 -MIRLET7A2 0 -MIRLET7A3 0 -MIRLET7B 0 -MIRLET7BHG 412 -MIRLET7C 2 -MIRLET7D 1 -MIRLET7DHG 42 -MIRLET7E 0 -MIRLET7F1 0 -MIRLET7F2 0 -MIRLET7G 0 -MIRLET7I 1 -MIS12 686 -MIS18A 137 -MIS18BP1 320 -MISP 70 -MITD1 412 -MITF 688 -MIXL1 5 -MKI67 52 -MKKS 1374 -MKL1 2117 -MKL2 3188 -MKLN1 6334 -MKLN1-AS 283 -MKNK1 1201 -MKNK1-AS1 44 -MKNK2 14610 -MKRN1 2447 -MKRN2 1251 -MKRN2OS 62 -MKRN3 102 -MKRN7P 128 -MKRN9P 1 -MKS1 317 -MKX 339 -MKX-AS1 7 -MLANA 34 -MLC1 9936 -MLEC 9498 -MLF1 829 -MLF2 8521 -MLH1 899 -MLH3 1020 -MLIP 95 -MLIP-IT1 0 -MLK7-AS1 14 -MLKL 2176 -MLLT1 6760 -MLLT10 1471 -MLLT10P1 8 -MLLT11 4560 -MLLT3 1340 -MLLT4 5344 -MLLT4-AS1 28 -MLLT6 1 -MLN 2 -MLNR 5 -MLPH 145 -MLST8 1365 -MLX 1035 -MLXIP 3177 -MLXIPL 566 -MLYCD 367 -MMAA 354 -MMAB 782 -MMACHC 219 -MMADHC 1128 -MMD 901 -MMD2 315 -MME 21 -MMEL1 1 -MMGT1 1770 -MMP1 4 -MMP10 7 -MMP11 0 -MMP12 7 -MMP13 2 -MMP14 1916 -MMP15 765 -MMP16 554 -MMP17 1877 -MMP19 78 -MMP2 423 -MMP20 1 -MMP21 9 -MMP23A 1 -MMP23B 7 -MMP24 587 -MMP24-AS1 2612 -MMP25 82 -MMP25-AS1 127 -MMP26 5 -MMP27 0 -MMP28 40 -MMP3 30 -MMP7 9 -MMP8 8 -MMP9 52 -MMRN1 391 -MMRN2 1275 -MMS19 1421 -MMS22L 257 -MN1 622 -MNAT1 713 -MND1 21 -MNDA 199 -MNS1 493 -MNT 2045 -MNX1 4 -MNX1-AS1 0 -MOAP1 1 -MOB1A 789 -MOB1B 1543 -MOB2 1179 -MOB3A 2537 -MOB3B 1070 -MOB3C 805 -MOB4 8 -MOBP 8392 -MOCOS 22 -MOCS1 937 -MOCS2 3052 -MOCS3 182 -MOG 8 -MOGAT1 1 -MOGAT2 0 -MOGAT3 0 -MOGS 1340 -MOK 1366 -MON1A 896 -MON1B 1233 -MON2 1717 -MORC1 16 -MORC2 1917 -MORC2-AS1 133 -MORC3 2062 -MORC4 879 -MORF4L1 4736 -MORF4L2 12146 -MORF4L2-AS1 106 -MORN1 402 -MORN2 610 -MORN3 109 -MORN4 1544 -MORN5 123 -MOS 0 -MOSPD1 235 -MOSPD2 413 -MOSPD3 438 -MOV10 2181 -MOV10L1 61 -MOXD1 1661 -MOXD2P 0 -MPC1 1073 -MPC1L 1 -MPC2 1740 -MPDU1 803 -MPDZ 6207 -MPEG1 52 -MPG 957 -MPHOSPH10 1333 -MPHOSPH6 593 -MPHOSPH8 9622 -MPHOSPH9 432 -MPI 1102 -MPL 47 -MPLKIP 577 -MPND 497 -MPO 23 -MPP1 723 -MPP2 1473 -MPP3 247 -MPP4 18 -MPP5 2206 -MPP6 1570 -MPP7 235 -MPPE1 251 -MPPED1 116 -MPPED2 1058 -MPRIP 10312 -MPST 938 -MPV17 1384 -MPV17L 2 -MPV17L2 530 -MPZ 308 -MPZL1 3088 -MPZL2 271 -MPZL3 141 -MR1 723 -MRAP 4 -MRAP2 735 -MRAS 8634 -MRC1 343 -MRC2 3251 -MRE11A 388 -MREG 334 -MRFAP1 13292 -MRFAP1L1 3175 -MRGBP 589 -MRGPRD 1 -MRGPRE 27 -MRGPRF 336 -MRGPRF-AS1 6 -MRGPRG 0 -MRGPRG-AS1 0 -MRGPRX1 0 -MRGPRX2 0 -MRGPRX3 4 -MRGPRX4 0 -MRI1 571 -MRLN 3 -MRM1 16 -MRO 2356 -MROH1 2237 -MROH2A 2 -MROH2B 1 -MROH5 0 -MROH6 0 -MROH7 113 -MROH7-TTC4 21 -MROH8 210 -MROH9 1 -MRPL1 490 -MRPL10 940 -MRPL11 382 -MRPL12 1011 -MRPL13 405 -MRPL14 523 -MRPL15 608 -MRPL16 506 -MRPL17 988 -MRPL18 3091 -MRPL19 1807 -MRPL2 396 -MRPL20 1533 -MRPL21 530 -MRPL22 545 -MRPL23 87 -MRPL23-AS1 3 -MRPL24 913 -MRPL27 949 -MRPL28 1220 -MRPL3 2120 -MRPL30 756 -MRPL32 749 -MRPL33 1012 -MRPL34 1565 -MRPL35 1029 -MRPL36 287 -MRPL37 916 -MRPL38 2005 -MRPL39 335 -MRPL4 1414 -MRPL40 846 -MRPL41 3264 -MRPL42 818 -MRPL42P5 7 -MRPL43 1360 -MRPL44 724 -MRPL45 35 -MRPL45P2 77 -MRPL46 418 -MRPL47 701 -MRPL48 639 -MRPL49 1238 -MRPL50 508 -MRPL51 1910 -MRPL52 752 -MRPL53 619 -MRPL54 764 -MRPL55 572 -MRPL57 1523 -MRPL9 1022 -MRPS10 733 -MRPS11 839 -MRPS12 298 -MRPS14 1120 -MRPS15 1252 -MRPS16 1207 -MRPS17 282 -MRPS18A 640 -MRPS18B 0 -MRPS18C 201 -MRPS2 906 -MRPS21 2516 -MRPS22 629 -MRPS23 567 -MRPS24 1 -MRPS25 2408 -MRPS26 1543 -MRPS27 1289 -MRPS28 562 -MRPS30 366 -MRPS31 575 -MRPS31P5 189 -MRPS33 734 -MRPS34 1568 -MRPS35 934 -MRPS36 57 -MRPS5 2495 -MRPS6 4748 -MRPS7 1019 -MRPS9 574 -MRRF 544 -MRS2 697 -MRS2P2 81 -MRTO4 685 -MRVI1 1762 -MRVI1-AS1 39 -MS4A1 14 -MS4A10 1 -MS4A12 0 -MS4A13 0 -MS4A14 1370 -MS4A15 4 -MS4A18 0 -MS4A2 1 -MS4A3 0 -MS4A4A 93 -MS4A5 0 -MS4A6A 1732 -MS4A6E 0 -MS4A7 838 -MS4A8 5 -MSANTD1 204 -MSANTD2 695 -MSANTD3 276 -MSANTD3-TMEFF1 6 -MSANTD4 1401 -MSC 20 -MSC-AS1 40 -MSGN1 0 -MSH2 761 -MSH3 627 -MSH4 27 -MSH5 0 -MSH5-SAPCD1 0 -MSH6 1104 -MSI1 1229 -MSI2 2479 -MSL1 2971 -MSL2 1332 -MSL3 1375 -MSL3P1 84 -MSLN 46 -MSMB 0 -MSMO1 2344 -MSMP 86 -MSN 12270 -MSR1 312 -MSRA 544 -MSRB1 407 -MSRB2 1650 -MSRB3 3308 -MSS51 277 -MST1 399 -MST1L 11 -MST1P2 119 -MST1R 56 -MSTN 37 -MSTO1 138 -MSTO2P 32 -MSX1 2695 -MSX2 106 -MSX2P1 3 -MT1A 46 -MT1B 1 -MT1DP 1 -MT1E 1173 -MT1F 446 -MT1G 197 -MT1H 9 -MT1HL1 0 -MT1IP 0 -MT1JP 21 -MT1L 130 -MT1M 499 -MT1X 469 -MT2A 3122 -MT3 9861 -MT4 1 -MTA1 3783 -MTA2 3696 -MTA3 2392 -MTAP 588 -MTBP 59 -MTCH1 14655 -MTCH2 1145 -MTCL1 755 -MTCP1 49 -MTDH 6198 -MTERF1 293 -MTERF2 878 -MTERF3 355 -MTERF4 1708 -MTF1 1774 -MTF2 542 -MTFMT 283 -MTFP1 182 -MTFR1 267 -MTFR1L 2528 -MTFR2 19 -MTG1 501 -MTG2 1039 -MTHFD1 857 -MTHFD1L 762 -MTHFD2 1708 -MTHFD2L 283 -MTHFD2P1 2 -MTHFR 1935 -MTHFS 64 -MTHFSD 468 -MTIF2 1159 -MTIF3 1115 -MTL5 51 -MTM1 742 -MTMR1 849 -MTMR10 202 -MTMR11 2155 -MTMR12 972 -MTMR14 665 -MTMR2 1174 -MTMR3 3141 -MTMR4 2616 -MTMR6 1117 -MTMR7 474 -MTMR8 19 -MTMR9 1502 -MTMR9LP 414 -MTNR1A 1 -MTNR1B 6 -MTO1 934 -MTOR 2694 -MTOR-AS1 2 -MTPAP 643 -MTPN 0 -MTR 1325 -MTRF1 397 -MTRF1L 552 -MTRNR2L1 270 -MTRNR2L10 76 -MTRNR2L2 4153 -MTRNR2L3 16 -MTRNR2L4 55 -MTRNR2L5 8 -MTRNR2L6 0 -MTRNR2L7 1 -MTRNR2L8 11663 -MTRNR2L9 41 -MTRR 978 -MTSS1 2900 -MTSS1L 63377 -MTTP 254 -MTURN 43801 -MTUS1 3498 -MTUS2 298 -MTUS2-AS1 2 -MTVR2 8 -MTX1 225 -MTX2 964 -MTX3 1034 -MUC1 393 -MUC12 229 -MUC13 8 -MUC15 3 -MUC16 0 -MUC17 0 -MUC19 2 -MUC2 4 -MUC20 14 -MUC21 0 -MUC22 0 -MUC3A 130 -MUC4 4 -MUC5AC 0 -MUC5B 2 -MUC6 3 -MUC7 0 -MUCL1 0 -MUL1 888 -MUM1 5623 -MUM1L1 1521 -MURC 145 -MUS81 1231 -MUSK 14 -MUSTN1 18 -MUT 1102 -MUTYH 743 -MVB12A 440 -MVB12B 2161 -MVD 1298 -MVK 451 -MVP 3974 -MX1 2922 -MX2 270 -MXD1 2688 -MXD3 139 -MXD4 6199 -MXI1 6108 -MXRA5 72 -MXRA7 2850 -MXRA8 1761 -MYADM 2648 -MYADML 0 -MYADML2 89 -MYB 20 -MYBBP1A 853 -MYBL1 129 -MYBL2 7 -MYBPC1 1663 -MYBPC2 31 -MYBPC3 12 -MYBPH 180 -MYBPHL 9 -MYC 459 -MYCBP 3 -MYCBP2 6482 -MYCBP2-AS1 2 -MYCBPAP 125 -MYCL 89 -MYCN 76 -MYCNOS 3 -MYCNUT 0 -MYCT1 226 -MYD88 481 -MYDGF 1720 -MYEF2 1892 -MYEOV 1 -MYEOV2 1631 -MYF5 0 -MYF6 2 -MYH1 0 -MYH10 5304 -MYH11 5 -MYH13 1 -MYH14 3843 -MYH15 121 -MYH16 0 -MYH2 1 -MYH3 273 -MYH4 7 -MYH6 17 -MYH7 571 -MYH7B 598 -MYH8 1 -MYH9 16248 -MYHAS 4 -MYL1 0 -MYL10 1 -MYL12A 1895 -MYL12B 3169 -MYL2 1 -MYL3 133 -MYL4 8 -MYL5 60 -MYL6 9789 -MYL6B 3220 -MYL7 52 -MYL9 3842 -MYLIP 1467 -MYLK 5408 -MYLK-AS1 42 -MYLK-AS2 1 -MYLK2 10 -MYLK3 485 -MYLK4 51 -MYLPF 4 -MYNN 637 -MYO10 4652 -MYO15A 338 -MYO15B 4245 -MYO16 683 -MYO16-AS1 5 -MYO18A 2620 -MYO18B 10 -MYO19 0 -MYO1A 9 -MYO1B 771 -MYO1C 2290 -MYO1D 730 -MYO1E 1063 -MYO1F 1170 -MYO1G 64 -MYO1H 16 -MYO3A 83 -MYO3B 349 -MYO5A 4301 -MYO5B 170 -MYO5C 897 -MYO6 3204 -MYO7A 2441 -MYO7B 66 -MYO9A 1818 -MYO9B 4362 -MYOC 5 -MYOCD 208 -MYOD1 0 -MYOF 1523 -MYOG 7 -MYOM1 1285 -MYOM2 34 -MYOM3 19 -MYOT 209 -MYOZ1 68 -MYOZ2 11 -MYOZ3 184 -MYPN 24 -MYPOP 1238 -MYRF 2498 -MYRFL 22 -MYRIP 1655 -MYSM1 1057 -MYT1 0 -MYT1L 1820 -MYT1L-AS1 12 -MYZAP 66 -MZB1 59 -MZF1 1744 -MZF1-AS1 190 -MZT1 479 -MZT2A 862 -MZT2B 2196 -N4BP1 2165 -N4BP2 433 -N4BP2L1 1260 -N4BP2L2 3867 -N4BP2L2-IT2 185 -N4BP3 268 -N6AMT1 265 -N6AMT2 255 -NAA10 1897 -NAA11 13 -NAA15 1656 -NAA16 2467 -NAA20 1124 -NAA25 827 -NAA30 1137 -NAA35 844 -NAA38 1223 -NAA40 793 -NAA50 2447 -NAA60 2136 -NAAA 589 -NAALAD2 730 -NAALADL1 141 -NAALADL2 48 -NAALADL2-AS1 0 -NAALADL2-AS2 0 -NAALADL2-AS3 0 -NAB1 2450 -NAB2 2607 -NABP1 316 -NABP2 1238 -NACA 8953 -NACA2 0 -NACAD 3340 -NACAP1 92 -NACC1 3130 -NACC2 7093 -NADK 1432 -NADK2 2008 -NADSYN1 1205 -NAE1 964 -NAF1 350 -NAGA 673 -NAGK 1214 -NAGLU 542 -NAGPA 407 -NAGPA-AS1 54 -NAGS 180 -NAIF1 352 -NAIP 30 -NALCN 1422 -NALCN-AS1 60 -NAMA 19 -NAMPT 1665 -NANOG 2 -NANOGNB 0 -NANOS1 721 -NANOS2 14 -NANOS3 156 -NANP 165 -NANS 879 -NAP1L1 12405 -NAP1L2 2288 -NAP1L3 5917 -NAP1L4 59 -NAP1L5 3866 -NAP1L6 111 -NAPA 3487 -NAPA-AS1 52 -NAPB 6604 -NAPEPLD 88 -NAPG 1790 -NAPRT 0 -NAPSA 54 -NAPSB 316 -NARF 1167 -NARFL 847 -NARR 0 -NARS 4353 -NARS2 395 -NASP 2196 -NAT1 64 -NAT10 1254 -NAT14 1236 -NAT16 73 -NAT2 6 -NAT6 126 -NAT8 28 -NAT8B 5 -NAT8L 10298 -NAT9 1254 -NATD1 694 -NAV1 3465 -NAV2 2788 -NAV2-AS2 5 -NAV2-AS4 5 -NAV2-AS5 2 -NAV3 908 -NBAS 1785 -NBAT1 16 -NBEA 1986 -NBEAL1 358 -NBEAL2 1254 -NBEAP1 26 -NBL1 84 -NBN 1922 -NBPF1 136 -NBPF10 120 -NBPF11 655 -NBPF12 416 -NBPF13P 0 -NBPF14 205 -NBPF15 285 -NBPF18P 0 -NBPF20 85 -NBPF22P 0 -NBPF25P 257 -NBPF3 135 -NBPF4 0 -NBPF6 0 -NBPF7 3 -NBPF8 1130 -NBPF9 118 -NBR1 4362 -NBR2 227 -NCALD 1592 -NCAM1 15248 -NCAM1-AS1 31 -NCAM2 1297 -NCAN 2177 -NCAPD2 1026 -NCAPD3 759 -NCAPG 22 -NCAPG2 224 -NCAPH 2 -NCAPH2 1928 -NCBP1 1672 -NCBP2 2584 -NCBP2-AS2 647 -NCCRP1 2 -NCDN 11066 -NCEH1 699 -NCF1 31 -NCF1B 14 -NCF1C 65 -NCF2 145 -NCF4 104 -NCK1 979 -NCK1-AS1 38 -NCK2 1976 -NCKAP1 8981 -NCKAP1L 432 -NCKAP5 448 -NCKAP5L 2021 -NCKIPSD 2147 -NCL 10140 -NCLN 1501 -NCMAP 81 -NCOA1 6643 -NCOA2 1422 -NCOA3 1856 -NCOA4 3580 -NCOA5 2550 -NCOA6 3171 -NCOA7 3333 -NCOA7-AS1 0 -NCOR1 8573 -NCOR1P1 2 -NCOR2 13885 -NCR1 0 -NCR2 2 -NCR3 0 -NCR3LG1 458 -NCRNA00250 1 -NCRUPAR 1 -NCS1 10220 -NCSTN 2839 -NDC1 320 -NDC80 3 -NDE1 0 -NDEL1 2456 -NDFIP1 9046 -NDFIP2 737 -NDFIP2-AS1 0 -NDN 4767 -NDNF 313 -NDNL2 0 -NDOR1 1560 -NDP 256 -NDRG1 6732 -NDRG2 30988 -NDRG3 3157 -NDRG4 12072 -NDST1 3638 -NDST2 1001 -NDST3 116 -NDST4 8 -NDUFA1 2030 -NDUFA10 2130 -NDUFA11 2341 -NDUFA12 1819 -NDUFA13 4316 -NDUFA2 1247 -NDUFA3 0 -NDUFA4 3232 -NDUFA4L2 633 -NDUFA5 2504 -NDUFA6 1 -NDUFA6-AS1 6 -NDUFA7 921 -NDUFA8 1685 -NDUFA9 845 -NDUFAB1 1197 -NDUFAF1 468 -NDUFAF2 528 -NDUFAF3 1987 -NDUFAF4 918 -NDUFAF4P1 4 -NDUFAF5 317 -NDUFAF6 334 -NDUFAF7 556 -NDUFB1 1218 -NDUFB10 2320 -NDUFB11 1758 -NDUFB2 1649 -NDUFB2-AS1 78 -NDUFB3 741 -NDUFB4 2329 -NDUFB5 1334 -NDUFB6 1094 -NDUFB7 2095 -NDUFB8 4896 -NDUFB9 2715 -NDUFC1 1394 -NDUFC2 1541 -NDUFC2-KCTD14 0 -NDUFS1 1196 -NDUFS2 2455 -NDUFS3 1352 -NDUFS4 631 -NDUFS5 3403 -NDUFS6 1441 -NDUFS7 2129 -NDUFS8 2040 -NDUFV1 2858 -NDUFV2 1881 -NDUFV2-AS1 45 -NDUFV3 1035 -NEAT1 80848 -NEB 411 -NEBL 12244 -NEBL-AS1 13 -NECAB1 2002 -NECAB2 2637 -NECAB3 712 -NECAP1 2153 -NECAP2 1274 -NEDD1 542 -NEDD4 791 -NEDD4L 2405 -NEDD8 1557 -NEDD8-MDP1 0 -NEDD9 1819 -NEFH 3627 -NEFL 5904 -NEFM 8516 -NEGR1 4481 -NEGR1-IT1 1 -NEIL1 970 -NEIL2 2177 -NEIL3 1 -NEK1 2305 -NEK10 154 -NEK11 892 -NEK2 6 -NEK3 276 -NEK4 1677 -NEK5 181 -NEK6 1184 -NEK7 3000 -NEK8 144 -NEK9 4291 -NELFA 1571 -NELFB 2496 -NELFCD 2270 -NELFE 0 -NELL1 63 -NELL2 2923 -NEMF 5258 -NEMP1 587 -NEMP2 92 -NENF 3314 -NEO1 3083 -NES 6714 -NET1 1828 -NETO1 170 -NETO2 262 -NEU1 28 -NEU2 0 -NEU3 157 -NEU4 0 -NEURL1 2051 -NEURL1-AS1 2 -NEURL1B 1364 -NEURL2 162 -NEURL3 15 -NEURL4 2121 -NEUROD1 21 -NEUROD2 20 -NEUROD4 0 -NEUROD6 0 -NEUROG1 0 -NEUROG2 2 -NEUROG3 2 -NEXN 854 -NEXN-AS1 54 -NF1 4220 -NF1P2 0 -NF2 2335 -NFAM1 222 -NFASC 7666 -NFAT5 6388 -NFATC1 676 -NFATC2 849 -NFATC2IP 1021 -NFATC3 2284 -NFATC4 2417 -NFE2 24 -NFE2L1 25795 -NFE2L2 5678 -NFE2L3 366 -NFE4 0 -NFIA 5666 -NFIA-AS1 2 -NFIA-AS2 83 -NFIB 4752 -NFIC 12266 -NFIL3 2870 -NFIX 13686 -NFKB1 1374 -NFKB2 2013 -NFKBIA 3665 -NFKBIB 1503 -NFKBID 415 -NFKBIE 431 -NFKBIL1 1 -NFKBIZ 1485 -NFRKB 1378 -NFS1 957 -NFU1 768 -NFX1 1938 -NFXL1 345 -NFYA 1378 -NFYB 1403 -NFYC 1720 -NFYC-AS1 142 -NGB 2643 -NGDN 634 -NGEF 1171 -NGF 16 -NGFR 1682 -NGFRAP1 9123 -NGLY1 661 -NGRN 11466 -NHEG1 0 -NHEJ1 310 -NHLH1 288 -NHLH2 520 -NHLRC1 36 -NHLRC2 551 -NHLRC3 478 -NHLRC4 46 -NHP2 1115 -NHS 1037 -NHS-AS1 0 -NHSL1 1124 -NHSL2 372 -NICN1 783 -NID1 1103 -NID2 230 -NIF3L1 286 -NIFK 490 -NIFK-AS1 358 -NIM1K 748 -NIN 1792 -NINJ1 1645 -NINJ2 87 -NINL 1409 -NIP7 438 -NIPA1 1872 -NIPA2 1373 -NIPAL1 17 -NIPAL2 163 -NIPAL3 3506 -NIPAL4 24 -NIPBL 3517 -NIPBL-AS1 656 -NIPSNAP1 1588 -NIPSNAP3A 562 -NIPSNAP3B 280 -NISCH 8680 -NIT1 887 -NIT2 462 -NKAIN1 211 -NKAIN2 645 -NKAIN3 103 -NKAIN4 991 -NKAP 835 -NKAPL 252 -NKAPP1 69 -NKD1 1183 -NKD2 0 -NKG7 14 -NKILA 45 -NKIRAS1 1259 -NKIRAS2 896 -NKPD1 25 -NKRF 3297 -NKTR 4521 -NKX1-1 0 -NKX1-2 1 -NKX2-1 3626 -NKX2-1-AS1 52 -NKX2-2 344 -NKX2-3 0 -NKX2-4 245 -NKX2-5 2 -NKX2-6 0 -NKX2-8 149 -NKX3-1 174 -NKX3-2 2 -NKX6-1 153 -NKX6-2 374 -NKX6-3 0 -NLE1 210 -NLGN1 751 -NLGN1-AS1 1 -NLGN2 6728 -NLGN3 1500 -NLGN4X 3237 -NLGN4Y 37 -NLGN4Y-AS1 0 -NLK 1010 -NLN 719 -NLRC3 321 -NLRC4 84 -NLRC5 835 -NLRP1 582 -NLRP10 0 -NLRP11 1 -NLRP12 2 -NLRP13 0 -NLRP14 3 -NLRP2 17 -NLRP3 105 -NLRP4 7 -NLRP5 0 -NLRP6 7 -NLRP7 0 -NLRP8 0 -NLRP9 4 -NLRX1 331 -NMB 776 -NMBR 5 -NMD3 539 -NME1 779 -NME1-NME2 15 -NME2 131 -NME3 1627 -NME4 3027 -NME5 390 -NME6 529 -NME7 465 -NME8 13 -NME9 137 -NMI 217 -NMNAT1 702 -NMNAT2 2873 -NMNAT3 286 -NMRAL1 5 -NMRK1 473 -NMRK2 38 -NMS 2 -NMT1 7278 -NMT2 1079 -NMU 37 -NMUR1 4 -NMUR2 57 -NNAT 3636 -NNMT 294 -NNT 898 -NNT-AS1 798 -NOA1 414 -NOB1 824 -NOBOX 0 -NOC2L 1633 -NOC3L 372 -NOC4L 301 -NOCT 507 -NOD1 946 -NOD2 65 -NODAL 13 -NOG 285 -NOL10 791 -NOL11 732 -NOL12 941 -NOL3 1183 -NOL4 1078 -NOL4L 1865 -NOL6 1180 -NOL7 1147 -NOL8 1487 -NOL9 1073 -NOLC1 2747 -NOM1 1086 -NOMO1 145 -NOMO2 134 -NOMO3 0 -NONO 4895 -NOP10 1053 -NOP14 1066 -NOP14-AS1 369 -NOP16 500 -NOP2 1851 -NOP56 4002 -NOP58 2536 -NOP9 1240 -NOS1 3015 -NOS1AP 1124 -NOS2 12 -NOS3 688 -NOSIP 1026 -NOSTRIN 50 -NOTCH1 7557 -NOTCH2 5831 -NOTCH2NL 16 -NOTCH3 2344 -NOTCH4 15 -NOTO 2 -NOTUM 40 -NOV 550 -NOVA1 5394 -NOVA2 1972 -NOX1 27 -NOX3 1 -NOX4 28 -NOX5 31 -NOXA1 370 -NOXO1 73 -NOXRED1 77 -NPAP1 91 -NPAS1 73 -NPAS2 1829 -NPAS3 2084 -NPAS4 1071 -NPAT 541 -NPB 286 -NPBWR1 30 -NPBWR2 0 -NPC1 1784 -NPC1L1 31 -NPC2 4592 -NPDC1 9488 -NPEPL1 45 -NPEPPS 4696 -NPFF 233 -NPFFR1 56 -NPFFR2 23 -NPHP1 861 -NPHP3 602 -NPHP3-ACAD11 161 -NPHP3-AS1 4 -NPHP4 699 -NPHS1 15 -NPHS2 0 -NPIPA1 197 -NPIPA2 0 -NPIPA3 0 -NPIPA5 1 -NPIPA7 0 -NPIPA8 0 -NPIPB11 94 -NPIPB15 86 -NPIPB3 420 -NPIPB4 89 -NPIPB5 507 -NPIPB6 19 -NPIPB8 0 -NPIPB9 2 -NPL 469 -NPLOC4 3235 -NPM1 2110 -NPM2 616 -NPM3 179 -NPNT 2860 -NPPA 22 -NPPA-AS1 42 -NPPB 3 -NPPC 115 -NPR1 227 -NPR2 1735 -NPR3 29 -NPRL2 742 -NPRL3 1807 -NPS 0 -NPSR1 6 -NPSR1-AS1 1 -NPTN 4900 -NPTN-IT1 91 -NPTX1 1868 -NPTX2 6824 -NPTXR 5659 -NPVF 299 -NPW 84 -NPY 6818 -NPY1R 1136 -NPY2R 324 -NPY4R 0 -NPY5R 97 -NPY6R 193 -NQO1 1497 -NQO2 820 -NR0B1 66 -NR0B2 7 -NR1D1 1457 -NR1D2 1775 -NR1H2 2565 -NR1H3 351 -NR1H4 4 -NR1I2 44 -NR1I3 16 -NR2C1 832 -NR2C2 3447 -NR2C2AP 204 -NR2E1 537 -NR2E3 24 -NR2F1 6121 -NR2F1-AS1 1096 -NR2F2 2800 -NR2F2-AS1 43 -NR2F6 1864 -NR3C1 2768 -NR3C2 1069 -NR4A1 9232 -NR4A2 1737 -NR4A3 2171 -NR5A1 152 -NR5A2 218 -NR6A1 344 -NRADDP 10 -NRAP 3 -NRARP 867 -NRAS 912 -NRAV 1071 -NRBF2 326 -NRBP1 2720 -NRBP2 5245 -NRCAM 7777 -NRD1 4067 -NRDE2 967 -NREP 296 -NREP-AS1 0 -NRF1 798 -NRG1 447 -NRG1-IT1 0 -NRG1-IT3 0 -NRG2 849 -NRG3 736 -NRG3-AS1 13 -NRG4 166 -NRGN 4381 -NRIP1 966 -NRIP2 525 -NRIP3 618 -NRIR 36 -NRK 10 -NRL 75 -NRM 11 -NRN1 500 -NRN1L 84 -NRON 16 -NRP1 1756 -NRP2 2004 -NRROS 157 -NRSN1 2437 -NRSN2 3157 -NRSN2-AS1 250 -NRTN 29 -NRXN1 2572 -NRXN2 11706 -NRXN3 2373 -NSA2 1759 -NSD1 4217 -NSDHL 643 -NSF 517 -NSFL1C 2947 -NSFP1 14 -NSG1 4180 -NSL1 1561 -NSMAF 988 -NSMCE1 823 -NSMCE2 289 -NSMCE4A 233 -NSMF 10035 -NSRP1 5146 -NSUN2 1357 -NSUN3 118 -NSUN4 1003 -NSUN5 383 -NSUN5P1 218 -NSUN5P2 38 -NSUN6 846 -NSUN7 147 -NT5C 650 -NT5C1A 18 -NT5C1B 3 -NT5C1B-RDH14 0 -NT5C2 4895 -NT5C3A 310 -NT5C3B 1624 -NT5DC1 376 -NT5DC2 1493 -NT5DC3 1241 -NT5E 2245 -NT5M 213 -NTAN1 107 -NTF3 7 -NTF4 2 -NTHL1 357 -NTM 2112 -NTM-IT 0 -NTMT1 369 -NTN1 1460 -NTN3 44 -NTN4 752 -NTN5 77 -NTNG1 531 -NTNG2 551 -NTPCR 610 -NTRK1 19 -NTRK2 37079 -NTRK3 2580 -NTRK3-AS1 8 -NTS 491 -NTSR1 42 -NTSR2 884 -NUAK1 1354 -NUAK2 201 -NUB1 2269 -NUBP1 426 -NUBP2 1029 -NUBPL 358 -NUCB1 10284 -NUCB1-AS1 128 -NUCB2 2822 -NUCKS1 12529 -NUDC 7133 -NUDCD1 483 -NUDCD2 493 -NUDCD3 3498 -NUDT1 149 -NUDT10 527 -NUDT11 1669 -NUDT12 470 -NUDT13 146 -NUDT14 430 -NUDT15 600 -NUDT16 5707 -NUDT16L1 1161 -NUDT16P1 136 -NUDT17 229 -NUDT18 182 -NUDT19 345 -NUDT2 373 -NUDT21 2956 -NUDT22 396 -NUDT3 550 -NUDT4 1268 -NUDT4P1 0 -NUDT4P2 0 -NUDT5 814 -NUDT6 33 -NUDT7 227 -NUDT8 123 -NUDT9 3138 -NUDT9P1 45 -NUF2 3 -NUFIP1 203 -NUFIP2 7951 -NUGGC 7 -NUMA1 10335 -NUMB 2538 -NUMBL 3760 -NUP107 287 -NUP133 906 -NUP153 1780 -NUP155 484 -NUP160 1089 -NUP188 2893 -NUP205 1349 -NUP210 1783 -NUP210L 112 -NUP210P1 0 -NUP214 1829 -NUP35 288 -NUP37 172 -NUP43 736 -NUP50 1047 -NUP50-AS1 433 -NUP54 358 -NUP62 2574 -NUP62CL 80 -NUP85 369 -NUP88 521 -NUP93 758 -NUP98 2492 -NUPL1 1396 -NUPL2 453 -NUPR1 9307 -NUPR1L 52 -NUS1 686 -NUSAP1 68 -NUTF2 1491 -NUTM1 6 -NUTM2A 6 -NUTM2A-AS1 173 -NUTM2B 2 -NUTM2B-AS1 392 -NUTM2D 34 -NUTM2F 0 -NUTM2G 52 -NVL 430 -NWD1 1296 -NWD2 119 -NXF1 6410 -NXF2 0 -NXF2B 0 -NXF3 8 -NXF4 5 -NXF5 4 -NXN 1120 -NXNL1 14 -NXNL2 56 -NXPE1 15 -NXPE2 14 -NXPE3 1697 -NXPE4 2 -NXPH1 579 -NXPH2 10 -NXPH3 1394 -NXPH4 40 -NXT1 339 -NXT2 280 -NYAP1 3653 -NYAP2 125 -NYNRIN 2479 -NYX 1 -OACYLP 0 -OAF 744 -OARD1 564 -OAS1 478 -OAS2 592 -OAS3 1503 -OASL 47 -OAT 2875 -OAZ1 17646 -OAZ2 5242 -OAZ3 67 -OBFC1 623 -OBP2A 1 -OBP2B 1 -OBSCN 1857 -OBSL1 5552 -OC90 8 -OCA2 82 -OCEL1 297 -OCIAD1 4802 -OCIAD2 454 -OCLM 10 -OCLN 7 -OCM 7 -OCM2 2 -OCRL 3364 -OCSTAMP 0 -ODAM 14 -ODC1 1430 -ODF1 1 -ODF2 1680 -ODF2L 1051 -ODF3 8 -ODF3B 302 -ODF3L1 30 -ODF3L2 47 -ODF4 0 -OFD1 2121 -OGDH 5860 -OGDHL 2774 -OGFOD1 1595 -OGFOD2 458 -OGFOD3 918 -OGFR 3246 -OGFR-AS1 20 -OGFRL1 2365 -OGFRP1 5 -OGG1 640 -OGN 766 -OGT 8035 -OIP5 14 -OIP5-AS1 719 -OIT3 22 -OLA1 1992 -OLAH 50 -OLFM1 3716 -OLFM2 3670 -OLFM3 409 -OLFM4 11 -OLFML1 136 -OLFML2A 581 -OLFML2B 258 -OLFML3 403 -OLIG1 3767 -OLIG2 865 -OLIG3 0 -OLMALINC 643 -OLR1 210 -OMA1 692 -OMD 265 -OMG 1142 -OMP 6 -ONECUT1 18 -ONECUT2 139 -ONECUT3 1 -OOEP 1 -OOSP1 4 -OOSP2 0 -OPA1 2510 -OPA1-AS1 7 -OPA3 1415 -OPALIN 41 -OPCML 1010 -OPHN1 1895 -OPLAH 375 -OPN1LW 0 -OPN1MW 0 -OPN1MW2 0 -OPN1SW 0 -OPN3 80 -OPN4 6 -OPN5 2 -OPRD1 19 -OPRK1 458 -OPRL1 25 -OPRM1 1117 -OPTC 2 -OPTN 5479 -OR10A2 3 -OR10A3 0 -OR10A4 2 -OR10A5 0 -OR10A6 0 -OR10A7 0 -OR10AD1 5 -OR10AG1 0 -OR10C1 0 -OR10G2 0 -OR10G3 0 -OR10G4 0 -OR10G7 0 -OR10G8 0 -OR10G9 0 -OR10H1 0 -OR10H2 0 -OR10H3 0 -OR10H4 0 -OR10H5 2 -OR10J1 0 -OR10J3 0 -OR10J5 0 -OR10K1 0 -OR10K2 0 -OR10P1 0 -OR10Q1 0 -OR10R2 0 -OR10S1 0 -OR10T2 0 -OR10V1 0 -OR10V2P 2 -OR10W1 0 -OR10X1 0 -OR10Z1 0 -OR11A1 0 -OR11G2 0 -OR11H1 0 -OR11H12 0 -OR11H2 0 -OR11H4 0 -OR11H6 0 -OR11L1 0 -OR12D2 0 -OR12D3 0 -OR13A1 0 -OR13C2 1 -OR13C3 1 -OR13C4 0 -OR13C5 1 -OR13C8 0 -OR13C9 0 -OR13D1 1 -OR13F1 0 -OR13G1 0 -OR13H1 0 -OR13J1 10 -OR14A16 0 -OR14C36 0 -OR14I1 0 -OR14J1 0 -OR1A1 0 -OR1A2 0 -OR1B1 0 -OR1C1 0 -OR1D2 0 -OR1D4 0 -OR1D5 1 -OR1E1 0 -OR1E2 0 -OR1F1 7 -OR1F2P 3 -OR1G1 0 -OR1I1 2 -OR1J1 0 -OR1J2 0 -OR1J4 0 -OR1K1 1 -OR1L1 0 -OR1L3 0 -OR1L4 0 -OR1L6 0 -OR1L8 3 -OR1M1 0 -OR1N1 0 -OR1N2 0 -OR1Q1 0 -OR1S1 0 -OR1S2 0 -OR2A1 0 -OR2A1-AS1 3 -OR2A12 0 -OR2A14 0 -OR2A2 0 -OR2A20P 0 -OR2A25 0 -OR2A4 0 -OR2A42 0 -OR2A5 0 -OR2A7 2 -OR2A9P 6 -OR2AE1 4 -OR2AG1 0 -OR2AG2 1 -OR2AK2 1 -OR2AP1 0 -OR2AT4 1 -OR2B11 2 -OR2B2 0 -OR2B3 0 -OR2B6 1 -OR2C1 1 -OR2C3 0 -OR2D2 1 -OR2D3 4 -OR2F1 0 -OR2F2 0 -OR2G2 0 -OR2G3 0 -OR2G6 0 -OR2H1 0 -OR2H2 0 -OR2J2 0 -OR2J3 0 -OR2K2 3 -OR2L13 77 -OR2L1P 0 -OR2L2 4 -OR2L3 0 -OR2L5 1 -OR2L8 0 -OR2M1P 0 -OR2M2 0 -OR2M3 0 -OR2M4 1 -OR2M5 0 -OR2M7 0 -OR2S2 0 -OR2T1 0 -OR2T10 0 -OR2T11 0 -OR2T12 0 -OR2T2 0 -OR2T27 0 -OR2T29 0 -OR2T3 0 -OR2T33 3 -OR2T34 0 -OR2T35 0 -OR2T4 0 -OR2T5 0 -OR2T6 0 -OR2T8 2 -OR2V1 0 -OR2V2 0 -OR2W1 0 -OR2W3 49 -OR2W5 0 -OR2Y1 0 -OR2Z1 0 -OR3A1 5 -OR3A2 2 -OR3A3 0 -OR3A4P 0 -OR4A15 0 -OR4A16 0 -OR4A47 0 -OR4A5 0 -OR4B1 0 -OR4C11 0 -OR4C12 0 -OR4C13 0 -OR4C15 0 -OR4C16 0 -OR4C3 0 -OR4C45 0 -OR4C46 0 -OR4C6 0 -OR4D1 0 -OR4D10 0 -OR4D11 0 -OR4D2 0 -OR4D5 0 -OR4D6 0 -OR4D9 0 -OR4E2 0 -OR4F13P 0 -OR4F15 0 -OR4F16 0 -OR4F17 0 -OR4F21 0 -OR4F29 0 -OR4F3 0 -OR4F4 0 -OR4F5 0 -OR4F6 0 -OR4K1 0 -OR4K13 0 -OR4K14 0 -OR4K15 0 -OR4K17 0 -OR4K2 0 -OR4K5 0 -OR4L1 0 -OR4M1 0 -OR4M2 0 -OR4N2 0 -OR4N3P 0 -OR4N4 0 -OR4N5 0 -OR4P4 0 -OR4Q3 0 -OR4S1 0 -OR4S2 0 -OR4X1 0 -OR4X2 0 -OR51A2 0 -OR51A4 0 -OR51A7 0 -OR51B2 1 -OR51B4 1 -OR51B5 2 -OR51B6 0 -OR51D1 0 -OR51E1 17 -OR51E2 6 -OR51F1 0 -OR51F2 0 -OR51G1 0 -OR51G2 0 -OR51I1 0 -OR51I2 0 -OR51L1 0 -OR51M1 0 -OR51Q1 0 -OR51S1 0 -OR51T1 0 -OR51V1 0 -OR52A1 0 -OR52A5 0 -OR52B2 0 -OR52B4 0 -OR52B6 15 -OR52D1 1 -OR52E2 0 -OR52E4 0 -OR52E6 0 -OR52E8 0 -OR52H1 1 -OR52I1 1 -OR52I2 0 -OR52J3 0 -OR52K1 0 -OR52K2 0 -OR52L1 0 -OR52M1 0 -OR52N1 1 -OR52N2 0 -OR52N4 3 -OR52N5 0 -OR52R1 0 -OR52W1 0 -OR56A1 0 -OR56A3 0 -OR56A4 0 -OR56A5 1 -OR56B1 3 -OR56B4 1 -OR5A1 0 -OR5A2 0 -OR5AC2 0 -OR5AK2 1 -OR5AK4P 16 -OR5AN1 0 -OR5AP2 0 -OR5AR1 0 -OR5AS1 0 -OR5AU1 0 -OR5B12 0 -OR5B17 0 -OR5B2 0 -OR5B21 0 -OR5B3 0 -OR5C1 0 -OR5D13 0 -OR5D14 0 -OR5D16 0 -OR5D18 0 -OR5E1P 0 -OR5F1 0 -OR5H1 0 -OR5H14 0 -OR5H15 0 -OR5H2 0 -OR5H6 0 -OR5I1 0 -OR5J2 0 -OR5K1 0 -OR5K2 0 -OR5K3 0 -OR5K4 0 -OR5L1 0 -OR5L2 0 -OR5M1 0 -OR5M10 0 -OR5M11 0 -OR5M3 0 -OR5M8 0 -OR5M9 0 -OR5P2 0 -OR5P3 0 -OR5R1 0 -OR5T1 0 -OR5T2 0 -OR5T3 0 -OR5V1 0 -OR5W2 0 -OR6A2 0 -OR6B1 0 -OR6B2 0 -OR6B3 0 -OR6C1 0 -OR6C2 0 -OR6C3 0 -OR6C4 0 -OR6C6 0 -OR6C65 0 -OR6C68 0 -OR6C70 0 -OR6C74 0 -OR6C75 0 -OR6C76 0 -OR6F1 0 -OR6K2 0 -OR6K3 0 -OR6K6 0 -OR6M1 0 -OR6N1 0 -OR6N2 0 -OR6P1 0 -OR6Q1 0 -OR6S1 0 -OR6T1 0 -OR6V1 0 -OR6W1P 0 -OR6X1 0 -OR6Y1 0 -OR7A10 0 -OR7A17 1 -OR7A5 51 -OR7C1 21 -OR7C2 1 -OR7D2 6 -OR7D4 0 -OR7E12P 22 -OR7E14P 57 -OR7E156P 0 -OR7E24 1 -OR7E2P 2 -OR7E37P 0 -OR7E47P 6 -OR7E5P 1 -OR7E91P 0 -OR7G1 0 -OR7G2 0 -OR7G3 0 -OR8A1 0 -OR8B12 0 -OR8B2 0 -OR8B3 0 -OR8B4 0 -OR8B8 0 -OR8D1 1 -OR8D2 0 -OR8D4 0 -OR8G1 0 -OR8G2 0 -OR8G5 1 -OR8H1 0 -OR8H2 0 -OR8H3 0 -OR8I2 0 -OR8J1 0 -OR8J3 0 -OR8K1 0 -OR8K3 0 -OR8K5 0 -OR8S1 1 -OR8U1 0 -OR8U8 0 -OR8U9 0 -OR9A2 0 -OR9A4 14 -OR9G1 0 -OR9G4 0 -OR9G9 0 -OR9I1 0 -OR9K2 0 -OR9Q1 0 -OR9Q2 0 -ORAI1 310 -ORAI2 4937 -ORAI3 404 -ORAOV1 589 -ORC1 28 -ORC2 453 -ORC3 804 -ORC4 1229 -ORC5 372 -ORC6 53 -ORM1 2 -ORM2 2 -ORMDL1 1686 -ORMDL2 247 -ORMDL3 1929 -OS9 7460 -OSBP 2394 -OSBP2 842 -OSBPL10 511 -OSBPL10-AS1 0 -OSBPL11 1219 -OSBPL1A 3260 -OSBPL2 2264 -OSBPL3 727 -OSBPL5 827 -OSBPL6 1556 -OSBPL7 1026 -OSBPL8 1629 -OSBPL9 1721 -OSCAR 2 -OSCP1 600 -OSER1 1143 -OSER1-AS1 668 -OSGEP 398 -OSGEPL1 249 -OSGEPL1-AS1 27 -OSGIN1 256 -OSGIN2 2223 -OSM 15 -OSMR 1936 -OSMR-AS1 3 -OSR1 63 -OSR2 13 -OST4 1573 -OSTC 637 -OSTCP1 11 -OSTF1 718 -OSTM1 1194 -OSTN 3 -OTC 6 -OTOA 5 -OTOF 220 -OTOG 15 -OTOGL 25 -OTOL1 0 -OTOP1 0 -OTOP2 0 -OTOP3 0 -OTOR 1 -OTOS 50 -OTP 1502 -OTUB1 3024 -OTUB2 0 -OTUD1 969 -OTUD3 791 -OTUD4 1876 -OTUD5 3814 -OTUD6A 0 -OTUD6B 338 -OTUD6B-AS1 1629 -OTUD7A 26 -OTUD7B 2919 -OTULIN 1282 -OTX1 32 -OTX2 214 -OTX2-AS1 2 -OVAAL 1 -OVCA2 88 -OVCH1 21 -OVCH1-AS1 10 -OVCH2 2 -OVGP1 189 -OVOL1 5 -OVOL1-AS1 2 -OVOL2 0 -OVOL3 11 -OXA1L 1210 -OXCT1 1988 -OXCT1-AS1 21 -OXCT2 8 -OXER1 114 -OXGR1 4 -OXLD1 505 -OXNAD1 265 -OXR1 1063 -OXSM 171 -OXSR1 1159 -OXT 3765 -OXTR 532 -P2RX1 26 -P2RX2 156 -P2RX3 0 -P2RX4 252 -P2RX5 188 -P2RX5-TAX1BP3 95 -P2RX6 279 -P2RX6P 4 -P2RX7 2286 -P2RY1 475 -P2RY10 6 -P2RY11 52 -P2RY12 160 -P2RY13 36 -P2RY14 34 -P2RY2 395 -P2RY4 4 -P2RY6 62 -P2RY8 0 -P3H1 499 -P3H2 1818 -P3H2-AS1 18 -P3H3 1123 -P3H4 812 -P4HA1 5670 -P4HA2 2259 -P4HA2-AS1 88 -P4HA3 35 -P4HB 9640 -P4HTM 3337 -PA2G4 2354 -PA2G4P4 148 -PAAF1 1005 -PABPC1 15557 -PABPC1L 562 -PABPC1L2A 250 -PABPC1L2B 122 -PABPC1L2B-AS1 3 -PABPC1P2 0 -PABPC3 43 -PABPC4 2321 -PABPC4L 132 -PABPC5 80 -PABPC5-AS1 2 -PABPN1 1555 -PABPN1L 4 -PACERR 8 -PACRG 454 -PACRG-AS1 24 -PACRGL 349 -PACS1 3556 -PACS2 6626 -PACSIN1 6371 -PACSIN2 4501 -PACSIN3 656 -PADI1 20 -PADI2 2936 -PADI3 1 -PADI4 10 -PADI6 0 -PAEP 3 -PAF1 2568 -PAFAH1B1 7214 -PAFAH1B2 4214 -PAFAH1B3 939 -PAFAH2 522 -PAG1 1173 -PAGE1 0 -PAGE2 0 -PAGE2B 3 -PAGE3 0 -PAGE4 4 -PAGE5 0 -PAGR1 4775 -PAH 69 -PAICS 2792 -PAIP1 1263 -PAIP2 4574 -PAIP2B 2092 -PAK1 1668 -PAK1IP1 474 -PAK2 3007 -PAK3 1584 -PAK4 1664 -PAK6 476 -PAK7 453 -PALB2 276 -PALD1 1413 -PALLD 8369 -PALM 12310 -PALM2 1575 -PALM2-AKAP2 4 -PALM3 1534 -PALMD 1575 -PAM 12578 -PAM16 3 -PAMR1 814 -PAN2 3998 -PAN3 976 -PAN3-AS1 61 -PANDAR 170 -PANK1 180 -PANK2 920 -PANK3 524 -PANK4 0 -PANO1 49 -PANX1 451 -PANX2 1201 -PANX3 9 -PAOX 167 -PAPD4 729 -PAPD5 3084 -PAPD7 1322 -PAPL 32 -PAPLN 3578 -PAPOLA 10057 -PAPOLB 9 -PAPOLG 912 -PAPPA 88 -PAPPA-AS1 0 -PAPPA2 81 -PAPSS1 1841 -PAPSS2 593 -PAQR3 1150 -PAQR4 562 -PAQR5 232 -PAQR6 6258 -PAQR7 564 -PAQR8 3928 -PAQR9 111 -PAQR9-AS1 6 -PARD3 2965 -PARD3-AS1 14 -PARD3B 1762 -PARD6A 470 -PARD6B 195 -PARD6G 1514 -PARD6G-AS1 562 -PARG 502 -PARGP1 63 -PARK2 314 -PARK7 5249 -PARL 630 -PARM1 7963 -PARN 0 -PARP1 3719 -PARP10 1451 -PARP11 426 -PARP12 597 -PARP14 2610 -PARP15 18 -PARP16 310 -PARP2 642 -PARP3 840 -PARP4 1116 -PARP6 2176 -PARP8 1126 -PARP9 1817 -PARPBP 12 -PARS2 132 -PART1 52 -PARTICL 71 -PARVA 1926 -PARVB 899 -PARVG 1335 -PASD1 0 -PASK 644 -PATE1 0 -PATE2 15 -PATE3 3 -PATE4 1 -PATL1 1524 -PATL2 19 -PATZ1 1354 -PAUPAR 5 -PAWR 260 -PAX1 1 -PAX2 545 -PAX3 23 -PAX4 0 -PAX5 52 -PAX6 1536 -PAX7 8 -PAX8 258 -PAX8-AS1 144 -PAX9 26 -PAXBP1 1208 -PAXBP1-AS1 213 -PAXIP1 327 -PAXIP1-AS1 244 -PAXIP1-AS2 139 -PBDC1 528 -PBK 6 -PBLD 178 -PBOV1 6 -PBRM1 2337 -PBX1 3348 -PBX2 3 -PBX3 1732 -PBX4 147 -PBXIP1 18552 -PC 3312 -PCA3 42 -PCAT1 6 -PCAT14 14 -PCAT18 8 -PCAT19 719 -PCAT2 0 -PCAT29 5 -PCAT4 0 -PCAT5 0 -PCAT6 46 -PCAT7 0 -PCBD1 3582 -PCBD2 246 -PCBP1 13222 -PCBP1-AS1 438 -PCBP2 10652 -PCBP2-OT1 17 -PCBP3 314 -PCBP4 3346 -PCCA 488 -PCCA-AS1 2 -PCCB 578 -PCDH1 2633 -PCDH10 2082 -PCDH11X 259 -PCDH11Y 7 -PCDH12 316 -PCDH15 1055 -PCDH17 4222 -PCDH18 464 -PCDH19 1018 -PCDH20 386 -PCDH7 5361 -PCDH8 336 -PCDH9 3542 -PCDH9-AS2 4 -PCDH9-AS3 4 -PCDH9-AS4 0 -PCDHA1 37 -PCDHA10 69 -PCDHA11 43 -PCDHA12 41 -PCDHA13 19 -PCDHA2 40 -PCDHA3 36 -PCDHA4 58 -PCDHA5 23 -PCDHA6 53 -PCDHA7 7 -PCDHA8 8 -PCDHA9 16 -PCDHAC1 53 -PCDHAC2 259 -PCDHB1 13 -PCDHB10 150 -PCDHB11 58 -PCDHB12 66 -PCDHB13 141 -PCDHB14 427 -PCDHB15 121 -PCDHB16 171 -PCDHB17P 15 -PCDHB18P 34 -PCDHB19P 29 -PCDHB2 100 -PCDHB3 87 -PCDHB4 627 -PCDHB5 275 -PCDHB6 90 -PCDHB7 187 -PCDHB8 37 -PCDHB9 275 -PCDHGA1 135 -PCDHGA10 209 -PCDHGA11 108 -PCDHGA12 570 -PCDHGA2 162 -PCDHGA3 122 -PCDHGA4 162 -PCDHGA5 136 -PCDHGA6 130 -PCDHGA7 126 -PCDHGA8 25 -PCDHGA9 207 -PCDHGB1 117 -PCDHGB2 211 -PCDHGB3 61 -PCDHGB4 116 -PCDHGB5 237 -PCDHGB6 234 -PCDHGB7 481 -PCDHGB8P 15 -PCDHGC3 2767 -PCDHGC4 371 -PCDHGC5 189 -PCED1A 2431 -PCED1B 169 -PCED1B-AS1 41 -PCF11 3085 -PCGEM1 0 -PCGF1 420 -PCGF2 1 -PCGF3 3127 -PCGF5 3194 -PCGF6 75 -PCID2 949 -PCIF1 1362 -PCK1 134 -PCK2 441 -PCLO 3920 -PCM1 5894 -PCMT1 2975 -PCMTD1 1988 -PCMTD2 829 -PCNA 389 -PCNA-AS1 0 -PCNAP1 0 -PCNP 3734 -PCNT 2857 -PCNX 2632 -PCNXL2 1330 -PCNXL3 1575 -PCNXL4 1612 -PCOLCE 488 -PCOLCE-AS1 19 -PCOLCE2 343 -PCP2 15 -PCP4 1069 -PCP4L1 336 -PCSK1 3177 -PCSK1N 29321 -PCSK2 1169 -PCSK4 621 -PCSK5 433 -PCSK6 498 -PCSK7 1120 -PCSK9 6 -PCTP 282 -PCYOX1 4389 -PCYOX1L 211 -PCYT1A 561 -PCYT1B 692 -PCYT1B-AS1 4 -PCYT2 1551 -PDAP1 2601 -PDC 9 -PDCD1 0 -PDCD10 739 -PDCD11 1397 -PDCD1LG2 36 -PDCD2 850 -PDCD2L 188 -PDCD4 4501 -PDCD4-AS1 55 -PDCD5 1146 -PDCD6 1668 -PDCD6IP 3031 -PDCD6IPP2 169 -PDCD7 1684 -PDCL 459 -PDCL2 0 -PDCL3 224 -PDCL3P4 119 -PDDC1 3564 -PDE10A 421 -PDE11A 267 -PDE12 824 -PDE1A 451 -PDE1B 722 -PDE1C 442 -PDE2A 1476 -PDE3A 880 -PDE3B 715 -PDE4A 1196 -PDE4B 2062 -PDE4C 196 -PDE4D 2219 -PDE4DIP 1794 -PDE5A 608 -PDE6A 18 -PDE6B 237 -PDE6C 18 -PDE6D 857 -PDE6G 12 -PDE6H 3 -PDE7A 556 -PDE7B 1360 -PDE8A 933 -PDE8B 2550 -PDE9A 784 -PDF 48 -PDGFA 1155 -PDGFB 595 -PDGFC 416 -PDGFD 334 -PDGFRA 1504 -PDGFRB 2139 -PDGFRL 239 -PDHA1 1685 -PDHA2 0 -PDHB 1040 -PDHX 972 -PDIA2 845 -PDIA3 9309 -PDIA3P1 1788 -PDIA4 9238 -PDIA5 206 -PDIA6 3782 -PDIK1L 323 -PDILT 1 -PDK1 166 -PDK2 1593 -PDK3 2545 -PDK4 6012 -PDLIM1 929 -PDLIM2 923 -PDLIM3 970 -PDLIM4 1826 -PDLIM5 7111 -PDLIM7 1486 -PDP1 1287 -PDP2 1416 -PDPK1 1916 -PDPN 792 -PDPR 754 -PDRG1 594 -PDS5A 4079 -PDS5B 2745 -PDSS1 86 -PDSS2 383 -PDX1 0 -PDX1-AS1 0 -PDXDC1 275 -PDXDC2P 744 -PDXK 11436 -PDXP 3972 -PDYN 201 -PDZD11 992 -PDZD2 2957 -PDZD3 10 -PDZD4 9232 -PDZD7 312 -PDZD8 1736 -PDZD9 17 -PDZK1 33 -PDZK1IP1 3 -PDZK1P1 26 -PDZRN3 1715 -PDZRN3-AS1 16 -PDZRN4 470 -PEA15 45322 -PEAK1 2862 -PEAR1 457 -PEBP1 25601 -PEBP4 595 -PECAM1 3234 -PECR 141 -PEF1 1999 -PEG10 21413 -PEG3 22179 -PEG3-AS1 0 -PELI1 1256 -PELI2 933 -PELI3 946 -PELO 671 -PELP1 3183 -PEMT 557 -PENK 704 -PEPD 1554 -PER1 7851 -PER2 1387 -PER3 1185 -PER4 0 -PERM1 26 -PERP 948 -PES1 1166 -PET100 470 -PET117 105 -PEX1 557 -PEX10 615 -PEX11A 481 -PEX11B 915 -PEX11G 43 -PEX12 624 -PEX13 881 -PEX14 1263 -PEX16 503 -PEX19 2367 -PEX2 1117 -PEX26 1837 -PEX3 229 -PEX5 1626 -PEX5L 1228 -PEX6 2083 -PEX7 142 -PF4 12 -PF4V1 1 -PFAS 447 -PFDN1 1292 -PFDN2 1713 -PFDN4 551 -PFDN5 5603 -PFDN6 0 -PFKFB1 11 -PFKFB2 1002 -PFKFB3 4403 -PFKFB4 425 -PFKL 4624 -PFKM 4450 -PFKP 6306 -PFN1 4439 -PFN1P2 22 -PFN2 7326 -PFN3 0 -PFN4 34 -PGA3 0 -PGA4 0 -PGA5 8 -PGAM1 486 -PGAM1P5 5 -PGAM2 933 -PGAM4 13 -PGAM5 1437 -PGAP1 3056 -PGAP2 415 -PGAP3 578 -PGBD1 418 -PGBD2 156 -PGBD3 0 -PGBD4 44 -PGBD5 1309 -PGC 0 -PGCP1 0 -PGD 2560 -PGF 458 -PGGT1B 252 -PGK1 5463 -PGK2 0 -PGLS 1000 -PGLYRP1 16 -PGLYRP2 0 -PGLYRP3 0 -PGLYRP4 0 -PGM1 1374 -PGM2 343 -PGM2L1 4383 -PGM3 1405 -PGM5 337 -PGM5-AS1 2 -PGM5P2 76 -PGM5P3-AS1 0 -PGM5P4-AS1 2 -PGP 1275 -PGPEP1 4530 -PGPEP1L 18 -PGR 624 -PGRMC1 5209 -PGRMC2 2634 -PGS1 1595 -PHACTR1 535 -PHACTR2 1725 -PHACTR3 1346 -PHACTR4 2308 -PHAX 2001 -PHB 2084 -PHB2 2037 -PHC1 955 -PHC2 2761 -PHC3 3326 -PHEX 249 -PHEX-AS1 17 -PHF1 1126 -PHF10 837 -PHF11 974 -PHF12 2543 -PHF13 917 -PHF14 2206 -PHF19 1857 -PHF2 4481 -PHF20 2637 -PHF20L1 2202 -PHF21A 3245 -PHF21B 580 -PHF23 1585 -PHF24 856 -PHF3 3632 -PHF5A 707 -PHF6 1176 -PHF7 74 -PHF8 2438 -PHGDH 3950 -PHGR1 1 -PHIP 5112 -PHKA1 996 -PHKA2 1067 -PHKA2-AS1 18 -PHKB 1770 -PHKG1 506 -PHKG2 1191 -PHLDA1 2386 -PHLDA2 0 -PHLDA3 1673 -PHLDB1 4929 -PHLDB2 645 -PHLDB3 379 -PHLPP1 4268 -PHLPP2 1239 -PHOSPHO1 77 -PHOSPHO2 78 -PHOSPHO2-KLHL23 0 -PHOX2A 22 -PHOX2B 0 -PHPT1 2378 -PHRF1 40 -PHTF1 1121 -PHTF2 480 -PHYH 736 -PHYHD1 1617 -PHYHIP 5568 -PHYHIPL 5684 -PHYKPL 921 -PI15 33 -PI16 1137 -PI3 0 -PI4K2A 1825 -PI4K2B 307 -PI4KA 5092 -PI4KAP1 180 -PI4KAP2 533 -PI4KB 3351 -PIANP 5752 -PIAS1 917 -PIAS2 1224 -PIAS3 1560 -PIAS4 1304 -PIBF1 534 -PICALM 4938 -PICK1 1633 -PID1 964 -PIDD1 1067 -PIEZO1 2298 -PIEZO2 111 -PIF1 65 -PIFO 705 -PIGA 716 -PIGB 162 -PIGBOS1 103 -PIGC 532 -PIGF 279 -PIGG 1179 -PIGH 515 -PIGK 1023 -PIGL 86 -PIGM 625 -PIGN 344 -PIGO 560 -PIGP 406 -PIGQ 2051 -PIGR 2 -PIGS 772 -PIGT 2661 -PIGU 498 -PIGV 683 -PIGW 0 -PIGX 1578 -PIGY 0 -PIGZ 411 -PIH1D1 972 -PIH1D2 122 -PIH1D3 14 -PIK3AP1 487 -PIK3C2A 2996 -PIK3C2B 1067 -PIK3C2G 11 -PIK3C3 633 -PIK3CA 900 -PIK3CB 1550 -PIK3CD 762 -PIK3CD-AS1 0 -PIK3CD-AS2 33 -PIK3CG 101 -PIK3IP1 766 -PIK3IP1-AS1 5 -PIK3R1 3705 -PIK3R2 2643 -PIK3R3 1956 -PIK3R4 753 -PIK3R5 375 -PIK3R6 89 -PIKFYVE 2015 -PILRA 351 -PILRB 236 -PIM1 945 -PIM2 563 -PIM3 2215 -PIN1 2954 -PIN1P1 1 -PIN4 521 -PIN4P1 61 -PINK1 3339 -PINK1-AS 365 -PINLYP 373 -PINX1 380 -PIP 0 -PIP4K2A 3884 -PIP4K2B 1 -PIP4K2C 1027 -PIP5K1A 1563 -PIP5K1B 818 -PIP5K1C 4522 -PIP5K1P1 29 -PIP5KL1 123 -PIPOX 249 -PIPSL 111 -PIR 279 -PIR-FIGF 4 -PIRT 583 -PISD 1467 -PISRT1 0 -PITHD1 3158 -PITPNA 4055 -PITPNA-AS1 151 -PITPNB 2509 -PITPNC1 3397 -PITPNM1 4464 -PITPNM2 2227 -PITPNM3 1142 -PITRM1 2018 -PITRM1-AS1 122 -PITX1 51 -PITX2 62 -PITX3 4 -PIWIL1 0 -PIWIL2 109 -PIWIL3 4 -PIWIL4 166 -PJA1 2114 -PJA2 8050 -PKD1 9474 -PKD1L1 69 -PKD1L2 97 -PKD1L3 16 -PKD1P1 1273 -PKD1P6 2780 -PKD2 1321 -PKD2L1 4 -PKD2L2 7 -PKDCC 1526 -PKDREJ 29 -PKHD1 5 -PKHD1L1 65 -PKI55 995 -PKIA 3023 -PKIA-AS1 6 -PKIB 220 -PKIG 2821 -PKLR 0 -PKM 21144 -PKMYT1 19 -PKN1 5274 -PKN2 1345 -PKN2-AS1 8 -PKN3 479 -PKNOX1 1260 -PKNOX2 712 -PKNOX2-AS1 0 -PKP1 24 -PKP2 547 -PKP3 23 -PKP4 7098 -PLA1A 849 -PLA2G10 4 -PLA2G12A 1652 -PLA2G12B 4 -PLA2G15 622 -PLA2G16 2443 -PLA2G1B 6 -PLA2G2A 44 -PLA2G2C 0 -PLA2G2D 0 -PLA2G2E 0 -PLA2G2F 0 -PLA2G3 8 -PLA2G4A 203 -PLA2G4B 19 -PLA2G4C 970 -PLA2G4D 2 -PLA2G4E 2 -PLA2G4E-AS1 0 -PLA2G4F 7 -PLA2G5 56 -PLA2G6 1560 -PLA2G7 28 -PLA2R1 549 -PLAA 704 -PLAC1 1 -PLAC4 233 -PLAC8 40 -PLAC8L1 53 -PLAC9 119 -PLAG1 194 -PLAGL1 289 -PLAGL2 867 -PLAT 698 -PLAU 86 -PLAUR 214 -PLB1 127 -PLBD1 273 -PLBD1-AS1 8 -PLBD2 1553 -PLCB1 1368 -PLCB2 975 -PLCB3 1239 -PLCB4 1252 -PLCD1 1808 -PLCD3 4332 -PLCD4 285 -PLCE1 1898 -PLCE1-AS1 6 -PLCE1-AS2 0 -PLCG1 6960 -PLCG1-AS1 50 -PLCG2 821 -PLCH1 744 -PLCH2 0 -PLCL1 2067 -PLCL2 562 -PLCXD1 153 -PLCXD2 13 -PLCXD2-AS1 0 -PLCXD3 2832 -PLCZ1 4 -PLD1 428 -PLD2 976 -PLD3 22922 -PLD4 338 -PLD5 211 -PLD6 783 -PLEC 29107 -PLEK 347 -PLEK2 5 -PLEKHA1 1467 -PLEKHA2 1775 -PLEKHA3 1043 -PLEKHA4 3128 -PLEKHA5 3516 -PLEKHA6 4995 -PLEKHA7 1289 -PLEKHA8 930 -PLEKHA8P1 101 -PLEKHB1 34459 -PLEKHB2 4103 -PLEKHD1 2 -PLEKHF1 252 -PLEKHF2 667 -PLEKHG1 2376 -PLEKHG2 863 -PLEKHG3 1012 -PLEKHG4 129 -PLEKHG4B 400 -PLEKHG5 1477 -PLEKHG6 31 -PLEKHG7 2 -PLEKHH1 2129 -PLEKHH2 843 -PLEKHH3 1141 -PLEKHJ1 733 -PLEKHM1 91 -PLEKHM1P 228 -PLEKHM2 4583 -PLEKHM3 2085 -PLEKHN1 11 -PLEKHO1 2451 -PLEKHO2 1357 -PLEKHS1 9 -PLET1 4 -PLG 5 -PLGLA 6 -PLGLB1 0 -PLGLB2 0 -PLGRKT 165 -PLIN1 516 -PLIN2 8753 -PLIN3 1058 -PLIN4 1265 -PLIN5 488 -PLK1 223 -PLK2 570 -PLK3 302 -PLK4 21 -PLK5 102 -PLLP 477 -PLN 193 -PLOD1 6591 -PLOD2 1859 -PLOD3 3935 -PLP1 28203 -PLP2 622 -PLRG1 1370 -PLS1 168 -PLS3 1450 -PLS3-AS1 17 -PLSCR1 1103 -PLSCR2 7 -PLSCR3 6 -PLSCR4 1806 -PLSCR5 0 -PLTP 5183 -PLVAP 1833 -PLXDC1 439 -PLXDC2 3108 -PLXNA1 4294 -PLXNA2 1871 -PLXNA3 4973 -PLXNA4 2103 -PLXNB1 9369 -PLXNB2 9458 -PLXNB3 2043 -PLXNC1 1772 -PLXND1 2759 -PM20D1 34 -PM20D2 1018 -PMAIP1 224 -PMCH 58 -PMCHL1 0 -PMCHL2 0 -PMEL 24 -PMEPA1 2621 -PMF1 330 -PMF1-BGLAP 18 -PMFBP1 31 -PML 2730 -PMM1 1184 -PMM2 328 -PMP2 12017 -PMP22 3000 -PMPCA 1180 -PMPCB 1050 -PMS1 557 -PMS2 298 -PMS2CL 122 -PMS2P1 108 -PMS2P2 13 -PMS2P3 121 -PMS2P4 70 -PMS2P5 16 -PMS2P7 3 -PMS2P9 12 -PMVK 1819 -PNCK 2207 -PNISR 16137 -PNKD 1867 -PNKP 849 -PNLDC1 410 -PNLIP 0 -PNLIPRP1 0 -PNLIPRP2 0 -PNLIPRP3 2 -PNMA1 5892 -PNMA2 8600 -PNMA3 1552 -PNMA5 2102 -PNMA6A 560 -PNMAL1 5326 -PNMAL2 5817 -PNMT 726 -PNN 7139 -PNO1 480 -PNOC 80 -PNP 1036 -PNPLA1 6 -PNPLA2 3453 -PNPLA3 29 -PNPLA4 1010 -PNPLA5 20 -PNPLA6 6862 -PNPLA7 1190 -PNPLA8 2601 -PNPO 1496 -PNPT1 1385 -PNRC1 4488 -PNRC2 1815 -POC1A 66 -POC1B 536 -POC1B-GALNT4 0 -POC5 128 -PODN 3803 -PODNL1 263 -PODXL 5473 -PODXL2 5541 -POF1B 4 -POFUT1 979 -POFUT2 2212 -POGK 2714 -POGLUT1 760 -POGZ 6689 -POLA1 543 -POLA2 167 -POLB 625 -POLD1 431 -POLD2 1516 -POLD3 540 -POLD4 706 -POLDIP2 1951 -POLDIP3 3215 -POLE 690 -POLE2 14 -POLE3 987 -POLE4 341 -POLG 1485 -POLG2 290 -POLH 1271 -POLI 990 -POLK 833 -POLL 608 -POLM 437 -POLN 237 -POLQ 20 -POLR1A 1080 -POLR1B 516 -POLR1C 559 -POLR1D 1595 -POLR1E 520 -POLR2A 5448 -POLR2B 2206 -POLR2C 1807 -POLR2D 606 -POLR2E 3354 -POLR2F 1457 -POLR2G 562 -POLR2H 1084 -POLR2I 989 -POLR2J 1002 -POLR2J2 12 -POLR2J3 20 -POLR2J4 873 -POLR2K 1516 -POLR2L 2227 -POLR2M 49 -POLR3A 1030 -POLR3B 323 -POLR3C 673 -POLR3D 663 -POLR3E 1392 -POLR3F 531 -POLR3G 310 -POLR3GL 857 -POLR3H 3173 -POLR3K 296 -POLRMT 1167 -POM121 1061 -POM121C 1288 -POM121L10P 8 -POM121L12 0 -POM121L1P 2 -POM121L2 5 -POM121L4P 0 -POM121L8P 7 -POM121L9P 232 -POMC 4020 -POMGNT1 2652 -POMGNT2 1529 -POMK 152 -POMP 1565 -POMT1 1855 -POMT2 1226 -POMZP3 0 -PON1 15 -PON2 5562 -PON3 56 -POP1 164 -POP4 690 -POP5 588 -POP7 592 -POPDC2 61 -POPDC3 402 -POR 3483 -PORCN 500 -POSTN 92 -POT1 573 -POT1-AS1 85 -POTEA 0 -POTEB 0 -POTEB2 0 -POTEB3 0 -POTEC 0 -POTED 0 -POTEE 0 -POTEF 1 -POTEG 0 -POTEH 0 -POTEH-AS1 0 -POTEI 24 -POTEJ 1 -POTEKP 0 -POTEM 0 -POU1F1 9 -POU2AF1 71 -POU2F1 2272 -POU2F2 2108 -POU2F3 5 -POU3F1 119 -POU3F2 907 -POU3F3 2818 -POU3F4 9 -POU4F1 13 -POU4F2 0 -POU4F3 4 -POU5F1 1 -POU5F1B 2 -POU5F1P3 7 -POU5F1P4 8 -POU5F1P5 20 -POU5F2 7 -POU6F1 1525 -POU6F2 17 -POU6F2-AS1 0 -PP12613 5 -PP14571 233 -PP2D1 15 -PP7080 420 -PPA1 3450 -PPA2 585 -PPAN 190 -PPAN-P2RY11 0 -PPAP2A 1167 -PPAP2B 2700 -PPAP2C 415 -PPAPDC1A 564 -PPAPDC1B 1181 -PPAPDC2 163 -PPAPDC3 507 -PPARA 2377 -PPARD 3876 -PPARG 144 -PPARGC1A 755 -PPARGC1B 352 -PPAT 283 -PPBP 24 -PPBPP2 1 -PPCDC 140 -PPCS 649 -PPDPF 6578 -PPEF1 55 -PPEF1-AS1 0 -PPEF2 26 -PPFIA1 2738 -PPFIA2 1204 -PPFIA3 3087 -PPFIA4 1919 -PPFIBP1 1897 -PPFIBP2 485 -PPHLN1 1253 -PPIA 1308 -PPIAL4A 2 -PPIAL4C 0 -PPIAL4D 0 -PPIAL4E 0 -PPIAL4F 0 -PPIAL4G 1 -PPIAP30 11 -PPIB 2412 -PPIC 247 -PPID 3379 -PPIE 928 -PPIEL 472 -PPIF 1045 -PPIG 7302 -PPIH 199 -PPIL1 1245 -PPIL2 969 -PPIL3 431 -PPIL4 1637 -PPIL6 764 -PPIP5K1 1076 -PPIP5K2 661 -PPL 437 -PPM1A 3185 -PPM1B 2638 -PPM1D 1124 -PPM1E 1293 -PPM1F 2911 -PPM1G 2747 -PPM1H 1006 -PPM1J 215 -PPM1K 8619 -PPM1L 420 -PPM1M 1132 -PPM1N 74 -PPME1 3738 -PPOX 377 -PPP1CA 1518 -PPP1CB 7007 -PPP1CC 4313 -PPP1R10 477 -PPP1R11 0 -PPP1R12A 4916 -PPP1R12B 3419 -PPP1R12C 7046 -PPP1R13B 2296 -PPP1R13L 576 -PPP1R14A 378 -PPP1R14B 723 -PPP1R14C 269 -PPP1R14D 3 -PPP1R15A 12885 -PPP1R15B 2806 -PPP1R16A 2191 -PPP1R16B 1168 -PPP1R17 331 -PPP1R18 1 -PPP1R1A 1238 -PPP1R1B 6058 -PPP1R1C 141 -PPP1R2 601 -PPP1R21 1605 -PPP1R26 1950 -PPP1R26-AS1 341 -PPP1R27 9 -PPP1R2P3 2 -PPP1R2P9 0 -PPP1R32 312 -PPP1R35 378 -PPP1R36 44 -PPP1R37 2321 -PPP1R3A 0 -PPP1R3B 1326 -PPP1R3C 1676 -PPP1R3D 293 -PPP1R3E 1143 -PPP1R3F 2495 -PPP1R3G 71 -PPP1R42 60 -PPP1R7 2197 -PPP1R8 1312 -PPP1R9A 2451 -PPP1R9B 8161 -PPP2CA 5245 -PPP2CB 7341 -PPP2R1A 7808 -PPP2R1B 1053 -PPP2R2A 2007 -PPP2R2B 2173 -PPP2R2B-IT1 0 -PPP2R2C 3390 -PPP2R2D 1619 -PPP2R3A 407 -PPP2R3B 274 -PPP2R3C 728 -PPP2R4 4420 -PPP2R5A 1708 -PPP2R5B 3339 -PPP2R5C 2821 -PPP2R5D 2227 -PPP2R5E 1408 -PPP3CA 4982 -PPP3CB 3376 -PPP3CB-AS1 140 -PPP3CC 606 -PPP3R1 4683 -PPP3R2 9 -PPP4C 1357 -PPP4R1 1825 -PPP4R1-AS1 10 -PPP4R1L 49 -PPP4R2 640 -PPP4R3A 2772 -PPP4R3B 3235 -PPP4R3CP 0 -PPP4R4 1 -PPP5C 2666 -PPP5D1 107 -PPP6C 2233 -PPP6R1 4445 -PPP6R2 3579 -PPP6R3 2550 -PPRC1 1271 -PPT1 4365 -PPT2 0 -PPT2-EGFL8 3 -PPTC7 741 -PPWD1 678 -PPY 0 -PPY2P 0 -PQBP1 1805 -PQLC1 2267 -PQLC2 666 -PQLC2L 16 -PQLC3 312 -PRAC1 0 -PRAC2 0 -PRADC1 518 -PRAF2 3455 -PRAM1 380 -PRAME 0 -PRAMEF1 0 -PRAMEF10 0 -PRAMEF11 0 -PRAMEF12 4 -PRAMEF14 0 -PRAMEF15 0 -PRAMEF16 0 -PRAMEF17 0 -PRAMEF19 0 -PRAMEF2 0 -PRAMEF20 0 -PRAMEF22 0 -PRAMEF25 0 -PRAMEF26 0 -PRAMEF4 0 -PRAMEF5 0 -PRAMEF6 0 -PRAMEF7 0 -PRAMEF8 0 -PRAMEF9 0 -PRAP1 7 -PRB1 0 -PRB2 3 -PRB3 0 -PRB4 0 -PRC1 180 -PRC1-AS1 26 -PRCAT47 15 -PRCC 1714 -PRCD 33 -PRCP 3100 -PRDM1 367 -PRDM10 707 -PRDM11 1440 -PRDM12 51 -PRDM13 38 -PRDM14 0 -PRDM15 576 -PRDM16 540 -PRDM2 2433 -PRDM4 1443 -PRDM5 212 -PRDM6 68 -PRDM7 5 -PRDM8 854 -PRDM9 0 -PRDX1 11261 -PRDX2 6574 -PRDX3 2739 -PRDX4 684 -PRDX5 6550 -PRDX6 8473 -PREB 1449 -PRELID1 334 -PRELID2 42 -PRELP 6170 -PREP 677 -PREPL 9757 -PREX1 8037 -PREX2 609 -PRF1 24 -PRG1 0 -PRG2 2 -PRG3 0 -PRG4 1138 -PRH1 0 -PRH1-PRR4 2 -PRH2 0 -PRICKLE1 417 -PRICKLE2 3356 -PRICKLE2-AS1 28 -PRICKLE2-AS2 1 -PRICKLE2-AS3 76 -PRICKLE3 291 -PRICKLE4 756 -PRIM1 133 -PRIM2 65 -PRIMA1 0 -PRIMPOL 195 -PRKAA1 918 -PRKAA2 597 -PRKAB1 487 -PRKAB2 879 -PRKACA 7250 -PRKACB 9686 -PRKACG 5 -PRKAG1 1140 -PRKAG2 1859 -PRKAG2-AS1 92 -PRKAG3 6 -PRKAR1A 12102 -PRKAR1B 11005 -PRKAR2A 659 -PRKAR2A-AS1 48 -PRKAR2B 1210 -PRKCA 4604 -PRKCA-AS1 5 -PRKCB 2689 -PRKCD 621 -PRKCDBP 312 -PRKCE 1033 -PRKCG 694 -PRKCH 662 -PRKCI 853 -PRKCQ 238 -PRKCQ-AS1 105 -PRKCSH 8208 -PRKCZ 1554 -PRKD1 917 -PRKD2 3353 -PRKD3 1199 -PRKDC 3863 -PRKG1 733 -PRKG1-AS1 7 -PRKG2 162 -PRKRA 567 -PRKRIP1 17 -PRKRIR 487 -PRKX 2429 -PRKX-AS1 0 -PRKXP1 606 -PRKY 23 -PRL 1 -PRLH 0 -PRLHR 129 -PRLR 1416 -PRM1 0 -PRM2 0 -PRM3 0 -PRMT1 2763 -PRMT2 8467 -PRMT3 455 -PRMT5 845 -PRMT5-AS1 13 -PRMT6 387 -PRMT7 681 -PRMT8 92 -PRMT9 414 -PRNCR1 55 -PRND 36 -PRNP 15047 -PRNT 0 -PRO1804 12 -PROB1 491 -PROC 71 -PROCA1 479 -PROCR 702 -PRODH 313 -PRODH2 1 -PROK1 32 -PROK2 40 -PROKR1 10 -PROKR2 9 -PROL1 0 -PROM1 77 -PROM2 129 -PROP1 0 -PRORSD1P 73 -PRORY 0 -PROS1 943 -PROSC 2548 -PROSER1 986 -PROSER2 173 -PROSER2-AS1 83 -PROSER3 278 -PROX1 1254 -PROX1-AS1 57 -PROX2 152 -PROZ 42 -PRPF18 464 -PRPF19 3888 -PRPF3 1785 -PRPF31 0 -PRPF38A 1479 -PRPF38B 6988 -PRPF39 1255 -PRPF4 755 -PRPF40A 3438 -PRPF40B 756 -PRPF4B 4867 -PRPF6 2775 -PRPF8 0 -PRPH 120 -PRPH2 98 -PRPS1 1086 -PRPS1L1 2 -PRPS2 413 -PRPSAP1 1172 -PRPSAP2 930 -PRR11 110 -PRR12 5281 -PRR13 918 -PRR14 2084 -PRR14L 1985 -PRR15 42 -PRR15L 6 -PRR16 136 -PRR18 207 -PRR19 61 -PRR20A 0 -PRR20B 0 -PRR20C 0 -PRR20D 0 -PRR20E 0 -PRR21 0 -PRR22 37 -PRR23A 0 -PRR23B 0 -PRR23C 0 -PRR23D1 0 -PRR23D2 0 -PRR25 9 -PRR26 37 -PRR27 0 -PRR29 548 -PRR29-AS1 55 -PRR3 0 -PRR30 0 -PRR32 5 -PRR34 22 -PRR34-AS1 225 -PRR35 0 -PRR36 3491 -PRR4 0 -PRR5 739 -PRR5-ARHGAP8 0 -PRR5L 407 -PRR7 646 -PRR7-AS1 46 -PRR9 0 -PRRC1 774 -PRRC2A 129 -PRRC2B 14080 -PRRC2C 12317 -PRRG1 668 -PRRG2 23 -PRRG3 72 -PRRG4 1230 -PRRT1 0 -PRRT2 6143 -PRRT3 1126 -PRRT3-AS1 81 -PRRT4 256 -PRRX1 2023 -PRRX2 43 -PRRX2-AS1 0 -PRSS1 0 -PRSS12 35 -PRSS16 21 -PRSS2 0 -PRSS21 1 -PRSS22 0 -PRSS23 829 -PRSS27 68 -PRSS3 195 -PRSS30P 73 -PRSS33 12 -PRSS35 49 -PRSS36 38 -PRSS37 8 -PRSS38 0 -PRSS3P2 0 -PRSS41 0 -PRSS42 5 -PRSS45 6 -PRSS46 28 -PRSS48 3 -PRSS50 163 -PRSS53 285 -PRSS54 4 -PRSS55 0 -PRSS56 101 -PRSS57 9 -PRSS58 0 -PRSS8 53 -PRTFDC1 746 -PRTG 460 -PRTN3 0 -PRUNE 1147 -PRUNE2 3688 -PRX 755 -PRY 0 -PRY2 0 -PSAP 36982 -PSAPL1 2 -PSAT1 3840 -PSCA 4 -PSD 5564 -PSD2 3632 -PSD3 5157 -PSD4 570 -PSEN1 1734 -PSEN2 594 -PSENEN 1269 -PSG1 0 -PSG10P 0 -PSG11 0 -PSG2 0 -PSG3 0 -PSG4 0 -PSG5 0 -PSG6 0 -PSG7 1 -PSG8 0 -PSG9 0 -PSIP1 7809 -PSKH1 712 -PSKH2 0 -PSMA1 2023 -PSMA2 1142 -PSMA3 1067 -PSMA3-AS1 1698 -PSMA4 1577 -PSMA5 1000 -PSMA6 1018 -PSMA7 2846 -PSMA8 1 -PSMB1 1785 -PSMB10 836 -PSMB11 1 -PSMB2 2202 -PSMB3 397 -PSMB4 3034 -PSMB5 2049 -PSMB6 1623 -PSMB7 780 -PSMB8 1 -PSMB8-AS1 7 -PSMB9 0 -PSMC1 40 -PSMC2 1743 -PSMC3 2624 -PSMC3IP 249 -PSMC4 1960 -PSMC5 4436 -PSMC6 1069 -PSMD1 3932 -PSMD10 2234 -PSMD11 2437 -PSMD12 1311 -PSMD13 1541 -PSMD14 1404 -PSMD2 4472 -PSMD3 2906 -PSMD4 2630 -PSMD5 790 -PSMD5-AS1 129 -PSMD6 1229 -PSMD6-AS2 131 -PSMD7 2110 -PSMD8 2835 -PSMD9 798 -PSME1 1308 -PSME2 1396 -PSME3 2300 -PSME4 1587 -PSMF1 2721 -PSMG1 326 -PSMG2 824 -PSMG3 638 -PSMG3-AS1 871 -PSMG4 253 -PSORS1C1 0 -PSORS1C2 1 -PSORS1C3 0 -PSPC1 1216 -PSPH 729 -PSPN 82 -PSRC1 659 -PSTK 151 -PSTPIP1 138 -PSTPIP2 162 -PTAFR 551 -PTAR1 2186 -PTBP1 5006 -PTBP2 1640 -PTBP3 1123 -PTCD1 7 -PTCD2 199 -PTCD3 2589 -PTCH1 1171 -PTCH2 1054 -PTCHD1 1197 -PTCHD1-AS 2 -PTCHD2 461 -PTCHD3 0 -PTCHD4 46 -PTCRA 0 -PTCSC3 15 -PTDSS1 1923 -PTDSS2 180 -PTEN 2995 -PTENP1 109 -PTENP1-AS 20 -PTER 397 -PTF1A 3 -PTGDR 97 -PTGDR2 45 -PTGDS 29495 -PTGER1 86 -PTGER2 50 -PTGER3 669 -PTGER4 163 -PTGER4P2-CDK2AP2P2 25 -PTGES 165 -PTGES2 1442 -PTGES2-AS1 9 -PTGES3 17441 -PTGES3L 41 -PTGES3L-AARSD1 3 -PTGFR 280 -PTGFRN 522 -PTGIR 16 -PTGIS 216 -PTGR1 616 -PTGR2 961 -PTGS1 515 -PTGS2 378 -PTH 0 -PTH1R 580 -PTH2 0 -PTH2R 229 -PTHLH 95 -PTK2 3364 -PTK2B 2287 -PTK6 105 -PTK7 1584 -PTMA 6235 -PTMS 13024 -PTN 3270 -PTOV1 8571 -PTOV1-AS1 522 -PTOV1-AS2 1222 -PTP4A1 6430 -PTP4A2 7016 -PTP4A3 0 -PTPDC1 1711 -PTPMT1 1041 -PTPN1 1359 -PTPN11 7679 -PTPN12 3585 -PTPN13 4251 -PTPN14 1600 -PTPN18 1615 -PTPN2 669 -PTPN20 173 -PTPN21 1944 -PTPN22 53 -PTPN23 4490 -PTPN3 244 -PTPN4 1113 -PTPN5 2504 -PTPN6 411 -PTPN7 92 -PTPN9 1547 -PTPRA 4951 -PTPRB 3751 -PTPRC 647 -PTPRCAP 207 -PTPRD 2192 -PTPRD-AS1 157 -PTPRD-AS2 2 -PTPRE 1119 -PTPRF 6356 -PTPRG 1187 -PTPRG-AS1 45 -PTPRH 203 -PTPRJ 2010 -PTPRK 3 -PTPRM 3469 -PTPRN 13443 -PTPRN2 5800 -PTPRO 957 -PTPRQ 21 -PTPRR 323 -PTPRS 7893 -PTPRT 6488 -PTPRU 2319 -PTPRVP 39 -PTPRZ1 5880 -PTRF 7554 -PTRH1 407 -PTRH2 447 -PTRHD1 427 -PTS 864 -PTTG1 185 -PTTG1IP 7769 -PTTG2 19 -PTTG3P 5 -PTX3 56 -PTX4 4 -PUF60 20 -PUM1 5954 -PUM2 4367 -PURA 7509 -PURB 2727 -PURG 795 -PUS1 579 -PUS10 203 -PUS3 977 -PUS7 432 -PUS7L 481 -PUSL1 282 -PVALB 0 -PVR 2969 -PVRIG 316 -PVRIG2P 0 -PVRL1 1597 -PVRL2 2058 -PVRL3 778 -PVRL3-AS1 1 -PVRL4 7 -PVT1 48 -PWAR1 22 -PWAR4 0 -PWAR5 692 -PWARSN 690 -PWP1 763 -PWP2 113 -PWRN1 72 -PWRN2 7 -PWRN3 10 -PWRN4 25 -PWWP2A 701 -PWWP2B 775 -PXDC1 2383 -PXDN 1036 -PXDNL 13 -PXK 1520 -PXMP2 315 -PXMP4 402 -PXN 3129 -PXN-AS1 36 -PXT1 2 -PXYLP1 632 -PYCARD 160 -PYCARD-AS1 10 -PYCR1 657 -PYCR2 2865 -PYCRL 0 -PYDC1 32 -PYDC2 0 -PYGB 5862 -PYGL 1205 -PYGM 589 -PYGO1 796 -PYGO2 2836 -PYHIN1 14 -PYROXD1 206 -PYROXD2 465 -PYURF 0 -PYY 3 -PYY2 64 -PZP 49 -QARS 1275 -QDPR 6203 -QKI 13386 -QPCT 1168 -QPCTL 297 -QPRT 456 -QRFP 13 -QRFPR 120 -QRICH1 2146 -QRICH2 1030 -QRSL1 440 -QSER1 1411 -QSOX1 2633 -QSOX2 1552 -QTRT1 1663 -QTRTD1 413 -R3HCC1 709 -R3HCC1L 471 -R3HDM1 1870 -R3HDM2 3321 -R3HDM4 1162 -R3HDML 0 -RAB10 4236 -RAB11A 4059 -RAB11B 6500 -RAB11B-AS1 108 -RAB11FIP1 664 -RAB11FIP2 1180 -RAB11FIP3 17 -RAB11FIP4 3732 -RAB11FIP5 2186 -RAB12 1786 -RAB13 4092 -RAB14 3582 -RAB15 1901 -RAB17 41 -RAB18 3564 -RAB19 0 -RAB1A 4081 -RAB1B 4013 -RAB20 232 -RAB21 2356 -RAB22A 2122 -RAB23 1419 -RAB24 2316 -RAB25 3 -RAB26 483 -RAB27A 1848 -RAB27B 393 -RAB28 1012 -RAB29 1785 -RAB2A 4757 -RAB2B 2047 -RAB30 2564 -RAB30-AS1 126 -RAB31 6840 -RAB32 212 -RAB33A 189 -RAB33B 385 -RAB34 885 -RAB35 1712 -RAB36 583 -RAB37 153 -RAB38 91 -RAB39A 497 -RAB39B 899 -RAB3A 5151 -RAB3B 3183 -RAB3C 358 -RAB3D 1027 -RAB3GAP1 3659 -RAB3GAP2 2819 -RAB3IL1 682 -RAB3IP 2207 -RAB40A 21 -RAB40AL 13 -RAB40B 943 -RAB40C 962 -RAB41 63 -RAB42 15 -RAB43 18 -RAB44 7 -RAB4A 1653 -RAB4B 0 -RAB4B-EGLN2 3 -RAB5A 3144 -RAB5B 7704 -RAB5C 4374 -RAB6A 4542 -RAB6B 7402 -RAB6C 28 -RAB6C-AS1 34 -RAB7A 9564 -RAB7B 27 -RAB8A 1331 -RAB8B 1110 -RAB9A 885 -RAB9B 703 -RAB9BP1 0 -RABAC1 3137 -RABEP1 4376 -RABEP2 662 -RABEPK 567 -RABGAP1 3830 -RABGAP1L 1856 -RABGEF1 938 -RABGGTA 592 -RABGGTB 1130 -RABIF 659 -RABL2A 362 -RABL2B 956 -RABL3 1048 -RABL6 5409 -RAC1 11067 -RAC2 188 -RAC3 903 -RACGAP1 196 -RACGAP1P 4 -RAD1 927 -RAD17 45 -RAD18 124 -RAD21 6348 -RAD21-AS1 12 -RAD21L1 2 -RAD23A 4584 -RAD23B 3931 -RAD50 3161 -RAD51 44 -RAD51-AS1 163 -RAD51AP1 14 -RAD51AP2 4 -RAD51B 68 -RAD51C 444 -RAD51D 285 -RAD51L3-RFFL 1 -RAD52 688 -RAD54B 89 -RAD54L 140 -RAD54L2 760 -RAD9A 323 -RAD9B 42 -RADIL 941 -RAE1 775 -RAET1E 24 -RAET1E-AS1 6 -RAET1G 3 -RAET1K 18 -RAET1L 0 -RAF1 3152 -RAG1 29 -RAG2 1 -RAI1 3271 -RAI1-AS1 7 -RAI14 882 -RAI2 825 -RALA 1690 -RALB 2126 -RALBP1 5731 -RALGAPA1 1244 -RALGAPA1P 158 -RALGAPA2 1228 -RALGAPB 2592 -RALGDS 6891 -RALGPS1 1389 -RALGPS2 709 -RALY 3806 -RALY-AS1 11 -RALYL 1054 -RAMP1 3059 -RAMP2 550 -RAMP2-AS1 329 -RAMP3 1596 -RAN 4793 -RANBP1 880 -RANBP10 1396 -RANBP17 236 -RANBP2 4423 -RANBP3 4291 -RANBP3L 902 -RANBP6 989 -RANBP9 3133 -RANGAP1 11535 -RANGRF 330 -RAP1A 2067 -RAP1B 658 -RAP1GAP 4689 -RAP1GAP2 2116 -RAP1GDS1 2011 -RAP2A 3340 -RAP2B 1037 -RAP2C 634 -RAP2C-AS1 61 -RAPGEF1 5988 -RAPGEF2 2984 -RAPGEF3 1715 -RAPGEF4 2039 -RAPGEF4-AS1 11 -RAPGEF5 1441 -RAPGEF6 1101 -RAPGEFL1 1340 -RAPH1 1866 -RAPSN 35 -RARA 1665 -RARA-AS1 62 -RARB 354 -RARG 977 -RARRES1 77 -RARRES2 2206 -RARRES3 910 -RARS 911 -RARS2 373 -RASA1 1431 -RASA2 1103 -RASA3 1220 -RASA4 36 -RASA4B 34 -RASA4CP 608 -RASAL1 600 -RASAL2 1796 -RASAL2-AS1 68 -RASAL3 340 -RASD1 6292 -RASD2 578 -RASEF 211 -RASGEF1A 1187 -RASGEF1B 690 -RASGEF1C 116 -RASGRF1 1107 -RASGRF2 1091 -RASGRF2-AS1 15 -RASGRP1 158 -RASGRP2 660 -RASGRP3 476 -RASGRP4 86 -RASIP1 579 -RASL10A 247 -RASL10B 1789 -RASL11A 221 -RASL11B 104 -RASL12 1631 -RASSF1 688 -RASSF1-AS1 47 -RASSF10 55 -RASSF2 1994 -RASSF3 2234 -RASSF4 2203 -RASSF5 507 -RASSF6 65 -RASSF7 10 -RASSF8 2278 -RASSF8-AS1 372 -RASSF9 146 -RAVER1 2587 -RAVER2 1141 -RAX 1263 -RAX2 3 -RB1 1953 -RB1CC1 3657 -RBAK 921 -RBAK-RBAKDN 0 -RBAKDN 1 -RBBP4 3003 -RBBP5 1046 -RBBP6 6989 -RBBP7 1870 -RBBP8 898 -RBBP8NL 0 -RBBP9 681 -RBCK1 3512 -RBFA 400 -RBFADN 41 -RBFOX1 1067 -RBFOX2 89 -RBFOX3 1584 -RBKS 89 -RBL1 266 -RBL2 2566 -RBM10 3035 -RBM11 127 -RBM12 1199 -RBM12B 761 -RBM12B-AS1 40 -RBM14 3368 -RBM14-RBM4 2 -RBM15 323 -RBM15B 1884 -RBM17 3899 -RBM18 960 -RBM19 1645 -RBM20 169 -RBM22 1667 -RBM23 2599 -RBM24 465 -RBM25 9784 -RBM26 2292 -RBM26-AS1 69 -RBM27 1419 -RBM28 1005 -RBM3 2106 -RBM33 4071 -RBM34 1061 -RBM38 1232 -RBM39 6216 -RBM4 821 -RBM41 1491 -RBM42 1569 -RBM43 201 -RBM44 11 -RBM45 167 -RBM46 25 -RBM47 1044 -RBM48 726 -RBM4B 982 -RBM5 3608 -RBM5-AS1 247 -RBM6 9194 -RBM7 481 -RBM8A 2670 -RBMS1 1243 -RBMS2 2326 -RBMS3 895 -RBMS3-AS1 0 -RBMS3-AS3 18 -RBMX 2111 -RBMX2 1062 -RBMXL1 747 -RBMXL2 7 -RBMXL3 6 -RBMY1A1 0 -RBMY1A3P 0 -RBMY1B 0 -RBMY1D 0 -RBMY1E 0 -RBMY1F 0 -RBMY1J 0 -RBMY2EP 0 -RBMY2FP 0 -RBMY3AP 0 -RBP1 1323 -RBP2 3 -RBP3 6 -RBP4 2701 -RBP5 34 -RBP7 204 -RBPJ 3427 -RBPJL 3 -RBPMS 1812 -RBPMS-AS1 54 -RBPMS2 317 -RBSN 1657 -RBX1 1066 -RC3H1 1795 -RC3H2 648 -RCAN1 3821 -RCAN2 2900 -RCAN3 169 -RCAN3AS 1 -RCBTB1 1874 -RCBTB2 1039 -RCC1 1190 -RCC2 2400 -RCCD1 422 -RCE1 557 -RCHY1 932 -RCL1 308 -RCN1 2073 -RCN2 2387 -RCN3 1185 -RCOR1 824 -RCOR2 203 -RCOR3 1357 -RCSD1 369 -RCVRN 163 -RD3 89 -RD3L 0 -RDH10 1341 -RDH10-AS1 41 -RDH11 3564 -RDH12 33 -RDH13 49 -RDH14 123 -RDH16 26 -RDH5 29 -RDH8 0 -RDM1 5 -RDX 4350 -REC114 1 -REC8 1200 -RECK 399 -RECQL 274 -RECQL4 413 -RECQL5 987 -REEP1 2260 -REEP2 7014 -REEP3 1270 -REEP4 307 -REEP5 6143 -REEP6 375 -REG1A 0 -REG1B 0 -REG1P 0 -REG3A 0 -REG3G 0 -REG4 0 -REL 610 -RELA 2854 -RELB 312 -RELL1 880 -RELL2 641 -RELN 992 -RELT 602 -REM1 22 -REM2 53 -REN 0 -RENBP 887 -REP15 110 -REPIN1 4869 -REPS1 1336 -REPS2 895 -RER1 2850 -RERE 9649 -REREP3 3 -RERG 638 -RERG-AS1 0 -RERGL 100 -RESP18 64 -REST 1379 -RET 362 -RETN 3 -RETNLB 0 -RETSAT 1108 -REV1 1826 -REV3L 1817 -REXO1 2140 -REXO1L2P 0 -REXO2 891 -REXO4 1149 -RFC1 1999 -RFC2 368 -RFC3 85 -RFC4 292 -RFC5 355 -RFESD 18 -RFFL 196 -RFK 1598 -RFNG 1645 -RFPL1 10 -RFPL1S 838 -RFPL2 195 -RFPL3 0 -RFPL3S 54 -RFPL4A 0 -RFPL4AL1 0 -RFPL4B 1 -RFT1 413 -RFTN1 1907 -RFTN2 2034 -RFWD2 802 -RFWD3 396 -RFX1 2301 -RFX2 1774 -RFX3 1609 -RFX3-AS1 45 -RFX4 1900 -RFX5 1173 -RFX6 5 -RFX7 853 -RFX8 11 -RFXANK 551 -RFXAP 199 -RGAG1 146 -RGAG4 2290 -RGCC 1732 -RGL1 2699 -RGL2 3 -RGL3 846 -RGL4 704 -RGMA 4936 -RGMB 3497 -RGMB-AS1 142 -RGN 684 -RGP1 401 -RGPD1 24 -RGPD2 2 -RGPD3 23 -RGPD4 42 -RGPD4-AS1 0 -RGPD5 0 -RGPD6 0 -RGPD8 0 -RGR 129 -RGS1 413 -RGS10 485 -RGS11 2505 -RGS12 2648 -RGS13 2 -RGS14 826 -RGS16 965 -RGS17 152 -RGS18 36 -RGS19 376 -RGS2 4173 -RGS20 210 -RGS21 0 -RGS22 154 -RGS3 1449 -RGS4 3440 -RGS5 3460 -RGS6 417 -RGS7 516 -RGS7BP 164 -RGS8 8 -RGS9 811 -RGS9BP 51 -RGSL1 1 -RHAG 0 -RHBDD1 651 -RHBDD2 15798 -RHBDD3 981 -RHBDF1 526 -RHBDF2 1334 -RHBDL1 568 -RHBDL2 114 -RHBDL3 388 -RHBG 1 -RHCE 12 -RHCG 127 -RHD 42 -RHEB 1836 -RHEBL1 102 -RHNO1 288 -RHO 35 -RHOA 9533 -RHOB 8970 -RHOBTB1 397 -RHOBTB2 2735 -RHOBTB3 3369 -RHOC 4837 -RHOD 269 -RHOF 38 -RHOG 1008 -RHOH 84 -RHOJ 904 -RHOQ 2437 -RHOT1 1547 -RHOT2 1867 -RHOU 1129 -RHOV 34 -RHOXF1 50 -RHOXF1-AS1 19 -RHOXF1P1 0 -RHOXF2 0 -RHOXF2B 0 -RHPN1 3691 -RHPN1-AS1 55 -RHPN2 489 -RIBC1 215 -RIBC2 152 -RIC1 700 -RIC3 1815 -RIC8A 2352 -RIC8B 1464 -RICTOR 1464 -RIF1 1496 -RIIAD1 78 -RILP 0 -RILPL1 1459 -RILPL2 661 -RIMBP2 2333 -RIMBP3 3 -RIMBP3B 0 -RIMBP3C 0 -RIMKLA 648 -RIMKLB 2964 -RIMS1 998 -RIMS2 1333 -RIMS3 2927 -RIMS4 1647 -RIN1 309 -RIN2 1905 -RIN3 705 -RING1 0 -RINL 408 -RINT1 428 -RIOK1 581 -RIOK2 718 -RIOK3 1249 -RIPK1 1160 -RIPK2 947 -RIPK3 39 -RIPK4 9 -RIPPLY1 2 -RIPPLY2 104 -RIPPLY3 4 -RIT1 979 -RIT2 239 -RITA1 850 -RLBP1 26 -RLF 1168 -RLIM 3308 -RLN1 1 -RLN2 7 -RLN3 1 -RLTPR 1399 -RMDN1 1230 -RMDN2 164 -RMDN2-AS1 0 -RMDN3 1838 -RMI1 546 -RMI2 14 -RMND1 391 -RMND5A 2588 -RMND5B 716 -RMRP 180 -RMST 168 -RN7SK 1484 -RN7SL1 2280 -RN7SL2 9079 -RNA18S5 40 -RNA28S5 81 -RNA45S5 460 -RNA5-8S5 0 -RNA5S1 0 -RNA5S10 0 -RNA5S11 0 -RNA5S12 0 -RNA5S13 0 -RNA5S14 0 -RNA5S15 0 -RNA5S16 0 -RNA5S17 0 -RNA5S2 0 -RNA5S3 0 -RNA5S4 0 -RNA5S5 0 -RNA5S6 0 -RNA5S7 0 -RNA5S8 0 -RNA5S9 9 -RNASE1 676 -RNASE10 0 -RNASE11 0 -RNASE12 0 -RNASE13 1 -RNASE2 57 -RNASE3 6 -RNASE4 793 -RNASE6 176 -RNASE7 0 -RNASE8 0 -RNASE9 0 -RNASEH1 572 -RNASEH1-AS1 125 -RNASEH2A 136 -RNASEH2B 235 -RNASEH2B-AS1 4 -RNASEH2C 1672 -RNASEK 203 -RNASEK-C17orf49 41 -RNASEL 443 -RNASET2 1751 -RND1 1015 -RND2 10683 -RND3 1045 -RNF10 6034 -RNF103 1677 -RNF103-CHMP3 0 -RNF11 6213 -RNF111 1301 -RNF112 973 -RNF113A 377 -RNF113B 8 -RNF114 2971 -RNF115 1061 -RNF121 478 -RNF122 673 -RNF123 1537 -RNF125 196 -RNF126 1041 -RNF126P1 4 -RNF128 245 -RNF13 1668 -RNF130 3790 -RNF133 7 -RNF135 498 -RNF138 543 -RNF138P1 44 -RNF139 736 -RNF139-AS1 147 -RNF14 1936 -RNF141 2038 -RNF144A 2191 -RNF144A-AS1 149 -RNF144B 982 -RNF145 4188 -RNF146 2046 -RNF148 1 -RNF149 894 -RNF150 710 -RNF151 3 -RNF152 107 -RNF157 2840 -RNF157-AS1 138 -RNF165 290 -RNF166 771 -RNF167 3415 -RNF168 1353 -RNF169 786 -RNF17 2 -RNF170 1219 -RNF175 448 -RNF180 810 -RNF181 620 -RNF182 651 -RNF183 4 -RNF185 948 -RNF186 0 -RNF187 6296 -RNF19A 2826 -RNF19B 822 -RNF2 580 -RNF20 2412 -RNF207 609 -RNF208 1492 -RNF212 101 -RNF212B 21 -RNF213 6337 -RNF214 1082 -RNF215 728 -RNF216 4040 -RNF216-IT1 14 -RNF216P1 1002 -RNF217 678 -RNF217-AS1 21 -RNF219 311 -RNF219-AS1 17 -RNF220 3465 -RNF222 2 -RNF223 0 -RNF224 45 -RNF225 0 -RNF24 1099 -RNF25 959 -RNF26 542 -RNF31 987 -RNF32 218 -RNF34 1098 -RNF38 1819 -RNF39 0 -RNF4 1665 -RNF40 3665 -RNF41 2514 -RNF43 216 -RNF44 2463 -RNF5 1 -RNF5P1 54 -RNF6 1654 -RNF7 1672 -RNF8 930 -RNFT1 314 -RNFT2 605 -RNGTT 1001 -RNH1 0 -RNLS 185 -RNMT 1697 -RNMTL1 358 -RNPC3 1136 -RNPEP 951 -RNPEPL1 1584 -RNPS1 3644 -RNU1-1 0 -RNU1-13P 2 -RNU1-2 0 -RNU1-27P 0 -RNU1-28P 0 -RNU1-3 0 -RNU1-4 0 -RNU105B 0 -RNU105C 0 -RNU11 116 -RNU12 3 -RNU2-1 0 -RNU2-2P 11 -RNU4-1 1 -RNU4-2 14 -RNU4ATAC 0 -RNU5A-1 6 -RNU5B-1 8 -RNU5D-1 0 -RNU5E-1 3 -RNU5F-1 6 -RNU6-1 0 -RNU6-10P 1 -RNU6-14P 0 -RNU6-15P 0 -RNU6-16P 0 -RNU6-19P 1 -RNU6-2 0 -RNU6-21P 0 -RNU6-23P 0 -RNU6-26P 7 -RNU6-28P 2 -RNU6-30P 5 -RNU6-31P 0 -RNU6-33P 0 -RNU6-34P 0 -RNU6-35P 1 -RNU6-36P 0 -RNU6-39P 0 -RNU6-42P 0 -RNU6-45P 0 -RNU6-46P 0 -RNU6-48P 0 -RNU6-52P 0 -RNU6-53P 0 -RNU6-55P 0 -RNU6-56P 0 -RNU6-57P 1 -RNU6-58P 0 -RNU6-59P 0 -RNU6-63P 0 -RNU6-64P 0 -RNU6-66P 0 -RNU6-67P 0 -RNU6-68P 0 -RNU6-69P 1 -RNU6-7 0 -RNU6-71P 0 -RNU6-72P 0 -RNU6-75P 0 -RNU6-76P 0 -RNU6-78P 0 -RNU6-79P 0 -RNU6-8 0 -RNU6-81P 0 -RNU6-82P 2 -RNU6-83P 0 -RNU6-9 0 -RNU6ATAC 2 -RNU7-1 0 -RNU86 1 -RNVU1-1 3 -RNVU1-14 1 -RNVU1-15 1 -RNVU1-17 0 -RNVU1-18 0 -RNVU1-19 1 -RNVU1-20 0 -RNVU1-3 15 -RNVU1-4 0 -RNVU1-6 0 -RNVU1-7 0 -RNVU1-8 0 -RNY1 8 -RNY3 0 -RNY4 2 -RNY5 1 -ROBO1 2522 -ROBO2 218 -ROBO3 1282 -ROBO4 604 -ROCK1 3581 -ROCK1P1 134 -ROCK2 1915 -ROGDI 1842 -ROM1 1072 -ROMO1 860 -ROPN1 1 -ROPN1B 5 -ROPN1L 110 -ROPN1L-AS1 6 -ROR1 209 -ROR1-AS1 4 -ROR2 203 -RORA 1430 -RORA-AS1 36 -RORA-AS2 4 -RORB 160 -RORB-AS1 9 -RORC 153 -ROS1 36 -RP1 3 -RP11-87M18.2 1 -RP1L1 3 -RP2 357 -RP9 625 -RP9P 1037 -RPA1 1833 -RPA2 889 -RPA3 151 -RPA4 19 -RPAIN 1298 -RPAP1 1009 -RPAP2 347 -RPAP3 837 -RPARP-AS1 294 -RPE 879 -RPE65 24 -RPEL1 50 -RPF1 1148 -RPF2 874 -RPGR 1591 -RPGRIP1 16 -RPGRIP1L 378 -RPH3A 1583 -RPH3AL 38 -RPIA 392 -RPL10 2345 -RPL10A 2301 -RPL10L 1 -RPL11 8025 -RPL12 2797 -RPL13 13215 -RPL13A 12147 -RPL13AP17 0 -RPL13AP20 9 -RPL13AP3 8 -RPL13AP5 2 -RPL13AP6 9 -RPL13P5 197 -RPL14 4508 -RPL15 11418 -RPL17 258 -RPL17-C18orf32 17 -RPL18 9959 -RPL18A 278 -RPL19 11231 -RPL19P12 536 -RPL21 103 -RPL21P28 8 -RPL21P44 122 -RPL22 1680 -RPL22L1 305 -RPL23 5966 -RPL23A 1506 -RPL23AP32 60 -RPL23AP53 215 -RPL23AP64 75 -RPL23AP7 159 -RPL23AP82 118 -RPL23AP87 2 -RPL23P8 67 -RPL24 4900 -RPL26 4397 -RPL26L1 159 -RPL27 4368 -RPL27A 5988 -RPL28 10461 -RPL29 2557 -RPL29P2 5 -RPL3 12648 -RPL30 7348 -RPL31 5505 -RPL31P11 1 -RPL32 6871 -RPL32P3 469 -RPL34 3426 -RPL34-AS1 3 -RPL35 4248 -RPL35A 4592 -RPL36 6470 -RPL36A 79 -RPL36A-HNRNPH2 0 -RPL36AL 1900 -RPL37 6567 -RPL37A 11850 -RPL38 5780 -RPL39 269 -RPL39L 184 -RPL3L 0 -RPL4 7774 -RPL41 189 -RPL5 6715 -RPL6 2806 -RPL7 652 -RPL7A 4016 -RPL7L1 259 -RPL8 15935 -RPL9 872 -RPLP0 3931 -RPLP0P2 15 -RPLP1 10355 -RPLP2 5333 -RPN1 5406 -RPN2 4878 -RPP14 1078 -RPP21 2 -RPP25 671 -RPP25L 315 -RPP30 629 -RPP38 429 -RPP40 114 -RPPH1 279 -RPRD1A 3028 -RPRD1B 881 -RPRD2 3760 -RPRM 513 -RPRML 57 -RPS10 42 -RPS10-NUDT3 0 -RPS10P7 113 -RPS11 12093 -RPS12 3959 -RPS13 2995 -RPS14 7905 -RPS14P3 55 -RPS15 3669 -RPS15A 1921 -RPS15AP10 138 -RPS16 6316 -RPS16P5 267 -RPS17 1687 -RPS18 4 -RPS18P9 208 -RPS19 6428 -RPS19BP1 2398 -RPS2 1849 -RPS20 5502 -RPS21 3481 -RPS23 7836 -RPS24 7732 -RPS25 3074 -RPS26 51 -RPS26P11 4 -RPS27 91 -RPS27A 3125 -RPS27L 1217 -RPS28 270 -RPS29 2014 -RPS2P32 57 -RPS3 9296 -RPS3A 295 -RPS4X 12678 -RPS4Y1 0 -RPS4Y2 0 -RPS5 4721 -RPS6 14022 -RPS6KA1 693 -RPS6KA2 5581 -RPS6KA2-AS1 1 -RPS6KA2-IT1 18 -RPS6KA3 2509 -RPS6KA4 1422 -RPS6KA5 482 -RPS6KA6 456 -RPS6KB1 1136 -RPS6KB2 695 -RPS6KC1 829 -RPS6KL1 975 -RPS7 387 -RPS7P5 0 -RPS8 6870 -RPS9 4 -RPSA 609 -RPSAP52 24 -RPSAP58 599 -RPSAP9 18 -RPTN 0 -RPTOR 2014 -RPUSD1 776 -RPUSD2 195 -RPUSD3 369 -RPUSD4 537 -RQCD1 1323 -RRAD 287 -RRAGA 2691 -RRAGB 707 -RRAGC 1508 -RRAGD 1795 -RRAS 1124 -RRAS2 388 -RRBP1 4723 -RREB1 794 -RRH 13 -RRM1 635 -RRM2 9 -RRM2B 1086 -RRN3 100 -RRN3P1 176 -RRN3P2 145 -RRN3P3 164 -RRNAD1 1053 -RRP1 909 -RRP12 1298 -RRP15 594 -RRP1B 1230 -RRP36 785 -RRP7A 1840 -RRP7BP 411 -RRP8 360 -RRP9 355 -RRS1 441 -RRS1-AS1 11 -RS1 54 -RSAD1 1534 -RSAD2 335 -RSBN1 1628 -RSBN1L 1803 -RSC1A1 63 -RSF1 5318 -RSG1 413 -RSL1D1 3621 -RSL24D1 1689 -RSPH1 1569 -RSPH10B 0 -RSPH10B2 0 -RSPH14 44 -RSPH3 381 -RSPH4A 378 -RSPH6A 4 -RSPH9 185 -RSPO1 4 -RSPO2 568 -RSPO3 243 -RSPO4 488 -RSPRY1 868 -RSRC1 527 -RSRC2 4499 -RSRP1 1983 -RSU1 1382 -RSU1P2 0 -RTBDN 202 -RTCA 876 -RTCA-AS1 41 -RTCB 1642 -RTEL1 144 -RTEL1-TNFRSF6B 3 -RTF1 2782 -RTFDC1 2695 -RTKN 1100 -RTKN2 25 -RTL1 269 -RTN1 15688 -RTN2 1160 -RTN3 12359 -RTN4 18404 -RTN4IP1 169 -RTN4R 313 -RTN4RL1 168 -RTN4RL2 53 -RTP1 126 -RTP2 2 -RTP3 0 -RTP4 41 -RTP5 8 -RTTN 219 -RUFY1 1996 -RUFY2 1328 -RUFY3 6108 -RUFY4 2 -RUNDC1 1355 -RUNDC3A 6069 -RUNDC3A-AS1 232 -RUNDC3B 769 -RUNX1 454 -RUNX1-IT1 6 -RUNX1T1 693 -RUNX2 395 -RUNX3 446 -RUSC1 3755 -RUSC1-AS1 85 -RUSC2 5401 -RUVBL1 780 -RUVBL1-AS1 0 -RUVBL2 2252 -RWDD1 1521 -RWDD2A 487 -RWDD2B 381 -RWDD3 258 -RWDD4 221 -RXFP1 279 -RXFP2 1 -RXFP3 0 -RXFP4 1 -RXRA 4247 -RXRB 0 -RXRG 1062 -RYBP 2785 -RYK 970 -RYR1 7409 -RYR2 1265 -RYR3 1003 -S100A1 2294 -S100A10 2821 -S100A11 1331 -S100A12 70 -S100A13 1199 -S100A14 27 -S100A16 866 -S100A2 25 -S100A3 14 -S100A4 425 -S100A5 0 -S100A6 7369 -S100A7 3 -S100A7A 0 -S100A7L2 0 -S100A8 224 -S100A9 554 -S100B 11754 -S100G 1 -S100P 11 -S100PBP 1577 -S100Z 17 -S1PR1 2124 -S1PR2 95 -S1PR3 1306 -S1PR4 22 -S1PR5 133 -SAA1 2 -SAA2 0 -SAA2-SAA4 0 -SAA3P 0 -SAA4 0 -SAAL1 212 -SAC3D1 309 -SACM1L 1815 -SACS 1987 -SACS-AS1 3 -SAE1 1916 -SAFB 4230 -SAFB2 7631 -SAG 4 -SAGE1 25 -SALL1 1054 -SALL2 3743 -SALL3 111 -SALL4 25 -SALRNA1 2 -SALRNA2 6 -SALRNA3 2 -SAMD1 1633 -SAMD10 190 -SAMD11 475 -SAMD12 724 -SAMD12-AS1 2 -SAMD13 46 -SAMD14 1399 -SAMD15 356 -SAMD3 59 -SAMD4A 9664 -SAMD4B 5437 -SAMD5 634 -SAMD7 0 -SAMD8 2428 -SAMD9 269 -SAMD9L 1013 -SAMHD1 3726 -SAMM50 780 -SAMSN1 104 -SAMSN1-AS1 0 -SAP130 1212 -SAP18 6963 -SAP25 943 -SAP30 738 -SAP30BP 2181 -SAP30L 1705 -SAP30L-AS1 166 -SAPCD1 0 -SAPCD1-AS1 1 -SAPCD2 223 -SAR1A 2404 -SAR1B 2015 -SARAF 17898 -SARDH 170 -SARM1 535 -SARNP 993 -SARS 5560 -SARS2 397 -SART1 2915 -SART3 2110 -SASH1 5324 -SASH3 309 -SASS6 165 -SAT1 8078 -SAT2 1955 -SATB1 2307 -SATB1-AS1 5 -SATB2 563 -SATB2-AS1 5 -SATL1 18 -SAV1 1678 -SAXO1 1 -SAXO2 77 -SAYSD1 497 -SBDS 3804 -SBDSP1 1432 -SBF1 7687 -SBF1P1 65 -SBF2 2233 -SBF2-AS1 174 -SBK1 1088 -SBK2 3 -SBK3 8 -SBNO1 3820 -SBNO2 49 -SBSN 8 -SBSPON 310 -SC5D 3725 -SCAF1 6946 -SCAF11 3289 -SCAF4 2136 -SCAF8 1822 -SCAI 1227 -SCAMP1 2535 -SCAMP1-AS1 122 -SCAMP2 1354 -SCAMP3 1 -SCAMP4 3467 -SCAMP5 5461 -SCAND1 1311 -SCAND2P 677 -SCAP 3347 -SCAPER 2609 -SCARA3 4464 -SCARA5 389 -SCARB1 2200 -SCARB2 6256 -SCARF1 51 -SCARF2 679 -SCARNA1 0 -SCARNA10 3 -SCARNA11 0 -SCARNA12 81 -SCARNA13 0 -SCARNA14 0 -SCARNA15 0 -SCARNA16 5 -SCARNA17 299 -SCARNA18 1 -SCARNA2 80 -SCARNA20 1 -SCARNA21 0 -SCARNA22 3 -SCARNA23 2 -SCARNA27 3 -SCARNA3 0 -SCARNA4 2 -SCARNA5 1 -SCARNA6 3 -SCARNA7 201 -SCARNA8 2 -SCARNA9 185 -SCARNA9L 10 -SCART1 108 -SCCPDH 2209 -SCD 12403 -SCD5 11710 -SCEL 8 -SCEL-AS1 0 -SCFD1 1287 -SCFD2 347 -SCG2 21538 -SCG3 6338 -SCG5 1 -SCGB1A1 1 -SCGB1B2P 162 -SCGB1C1 0 -SCGB1C2 0 -SCGB1D1 0 -SCGB1D2 26 -SCGB1D4 0 -SCGB2A1 2 -SCGB2A2 2 -SCGB2B2 6 -SCGB2B3P 1 -SCGB3A1 99 -SCGB3A2 47 -SCGN 379 -SCHIP1 69 -SCHLAP1 0 -SCIMP 78 -SCIN 720 -SCLT1 234 -SCLY 10 -SCMH1 1569 -SCML1 298 -SCML2 90 -SCML4 20 -SCN10A 2 -SCN11A 26 -SCN1A 1644 -SCN1B 682 -SCN2A 2422 -SCN2B 2216 -SCN3A 2558 -SCN3B 3400 -SCN4A 38 -SCN4B 363 -SCN5A 212 -SCN7A 578 -SCN8A 1128 -SCN9A 1930 -SCNM1 19 -SCNN1A 28 -SCNN1B 8 -SCNN1D 753 -SCNN1G 10 -SCO1 486 -SCO2 22 -SCOC 3728 -SCOC-AS1 49 -SCP2 3192 -SCP2D1 0 -SCPEP1 1934 -SCRG1 1445 -SCRIB 0 -SCRN1 13119 -SCRN2 786 -SCRN3 601 -SCRT1 737 -SCRT2 3 -SCT 0 -SCTR 7 -SCUBE1 117 -SCUBE2 292 -SCUBE3 489 -SCX 530 -SCYL1 2830 -SCYL2 1046 -SCYL3 257 -SDAD1 1315 -SDC1 179 -SDC2 5061 -SDC3 9911 -SDC4 2167 -SDC4P 0 -SDCBP 4757 -SDCBP2 14 -SDCBP2-AS1 213 -SDCCAG3 893 -SDCCAG8 0 -SDE2 782 -SDF2 1133 -SDF2L1 1433 -SDF4 5294 -SDHA 1469 -SDHAF1 376 -SDHAF2 879 -SDHAF3 241 -SDHAF4 229 -SDHAP1 205 -SDHAP2 69 -SDHAP3 384 -SDHB 1344 -SDHC 759 -SDHD 837 -SDK1 1157 -SDK2 1292 -SDPR 866 -SDR16C5 20 -SDR16C6P 0 -SDR39U1 292 -SDR42E1 30 -SDR9C7 5 -SDS 116 -SDSL 239 -SEBOX 0 -SEC11A 1800 -SEC11C 3303 -SEC13 2168 -SEC14L1 5442 -SEC14L1P1 32 -SEC14L2 1610 -SEC14L3 2 -SEC14L4 47 -SEC14L5 232 -SEC14L6 79 -SEC16A 3540 -SEC16B 219 -SEC1P 25 -SEC22A 445 -SEC22B 623 -SEC22C 2186 -SEC23A 1904 -SEC23B 1472 -SEC23IP 713 -SEC24A 722 -SEC24B 1444 -SEC24B-AS1 15 -SEC24C 3579 -SEC24D 1048 -SEC31A 4662 -SEC31B 1239 -SEC61A1 6817 -SEC61A2 1702 -SEC61B 1473 -SEC61G 495 -SEC62 16612 -SEC63 3732 -SECISBP2 2071 -SECISBP2L 3895 -SECTM1 332 -SEH1L 921 -SEL1L 3182 -SEL1L2 4 -SEL1L3 529 -SELE 1149 -SELENBP1 1110 -SELK 1630 -SELL 921 -SELM 3701 -SELO 1319 -SELP 79 -SELPLG 1026 -SELT 2505 -SELV 8 -SEMA3A 168 -SEMA3B 4204 -SEMA3B-AS1 16 -SEMA3C 468 -SEMA3D 438 -SEMA3E 215 -SEMA3F 1472 -SEMA3G 672 -SEMA4A 1377 -SEMA4B 2132 -SEMA4C 1206 -SEMA4D 2882 -SEMA4F 810 -SEMA4G 586 -SEMA5A 2462 -SEMA5B 152 -SEMA6A 2750 -SEMA6A-AS1 18 -SEMA6B 4089 -SEMA6C 1303 -SEMA6D 1033 -SEMA7A 307 -SEMG1 0 -SEMG2 0 -SENCR 23 -SENP1 654 -SENP2 1451 -SENP3 585 -SENP3-EIF4A1 16 -SENP5 2231 -SENP6 3273 -SENP7 872 -SENP8 154 -SEP15 3145 -SEPHS1 1349 -SEPHS2 927 -SEPN1 5385 -SEPP1 1222 -SEPSECS 289 -SEPSECS-AS1 114 -SEPT1 200 -SEPT10 608 -SEPT11 4857 -SEPT12 18 -SEPT14 10 -SEPT2 12418 -SEPT3 9127 -SEPT4 6903 -SEPT4-AS1 25 -SEPT5 23 -SEPT5-GP1BB 242 -SEPT6 1839 -SEPT7 6188 -SEPT7-AS1 47 -SEPT7P2 475 -SEPT7P9 22 -SEPT8 7697 -SEPT9 8855 -SEPW1 12541 -SERAC1 567 -SERBP1 3974 -SERF1A 0 -SERF1B 0 -SERF2 7525 -SERF2-C15ORF63 1 -SERGEF 1467 -SERHL 22 -SERHL2 200 -SERINC1 16920 -SERINC2 74 -SERINC3 2599 -SERINC4 316 -SERINC5 1188 -SERP1 5486 -SERP2 827 -SERPINA1 101 -SERPINA10 0 -SERPINA11 0 -SERPINA12 0 -SERPINA13P 0 -SERPINA2 0 -SERPINA3 28950 -SERPINA4 0 -SERPINA5 799 -SERPINA6 0 -SERPINA7 0 -SERPINA9 0 -SERPINB1 854 -SERPINB10 0 -SERPINB11 2 -SERPINB12 2 -SERPINB13 3 -SERPINB2 0 -SERPINB3 1 -SERPINB4 0 -SERPINB5 1 -SERPINB6 2899 -SERPINB7 0 -SERPINB8 261 -SERPINB9 691 -SERPINB9P1 40 -SERPINC1 37 -SERPIND1 43 -SERPINE1 1378 -SERPINE2 3908 -SERPINE3 7 -SERPINF1 409 -SERPINF2 2 -SERPING1 5803 -SERPINH1 41707 -SERPINI1 2958 -SERPINI2 277 -SERTAD1 898 -SERTAD2 621 -SERTAD3 417 -SERTAD4 97 -SERTAD4-AS1 109 -SERTM1 65 -SESN1 2243 -SESN2 2815 -SESN3 8172 -SESTD1 2024 -SET 5617 -SETBP1 1492 -SETD1A 2603 -SETD1B 2629 -SETD2 3574 -SETD3 2773 -SETD4 533 -SETD5 8825 -SETD6 493 -SETD7 2412 -SETD8 600 -SETD9 105 -SETDB1 932 -SETDB2 437 -SETMAR 456 -SETSIP 210 -SETX 3650 -SEZ6 919 -SEZ6L 5779 -SEZ6L2 12081 -SF1 10027 -SF3A1 4065 -SF3A2 2248 -SF3A3 1506 -SF3B1 8467 -SF3B2 7363 -SF3B3 3672 -SF3B4 2754 -SF3B5 1095 -SF3B6 1096 -SFI1 1029 -SFMBT1 430 -SFMBT2 3114 -SFN 35 -SFPQ 8175 -SFR1 89 -SFRP1 252 -SFRP2 1454 -SFRP4 563 -SFRP5 96 -SFSWAP 2804 -SFT2D1 1009 -SFT2D2 110 -SFT2D3 301 -SFTA1P 18 -SFTA2 0 -SFTA3 1463 -SFTPA1 1 -SFTPA2 5 -SFTPB 1190 -SFTPC 59 -SFTPD 69 -SFXN1 1475 -SFXN2 63 -SFXN3 1413 -SFXN4 469 -SFXN5 3003 -SGCA 43 -SGCB 4187 -SGCD 502 -SGCE 2000 -SGCG 16 -SGCZ 31 -SGIP1 1551 -SGK1 1021 -SGK2 99 -SGK223 353 -SGK3 13 -SGK494 1233 -SGMS1 1462 -SGMS1-AS1 46 -SGMS2 1047 -SGOL1 50 -SGOL1-AS1 12 -SGOL2 116 -SGPL1 1661 -SGPP1 894 -SGPP2 392 -SGSH 993 -SGSM1 3681 -SGSM2 7376 -SGSM3 3343 -SGTA 3642 -SGTB 1086 -SH2B1 4270 -SH2B2 631 -SH2B3 1042 -SH2D1A 16 -SH2D1B 2 -SH2D2A 34 -SH2D3A 43 -SH2D3C 714 -SH2D4A 466 -SH2D4B 3 -SH2D5 312 -SH2D6 18 -SH2D7 46 -SH3BGR 1795 -SH3BGRL 4543 -SH3BGRL2 3715 -SH3BGRL3 5050 -SH3BP1 365 -SH3BP2 3140 -SH3BP4 943 -SH3BP5 338 -SH3BP5-AS1 580 -SH3BP5L 1725 -SH3D19 1025 -SH3D21 308 -SH3GL1 2027 -SH3GL1P1 145 -SH3GL1P2 4 -SH3GL2 1439 -SH3GL3 873 -SH3GLB1 3038 -SH3GLB2 4433 -SH3KBP1 2593 -SH3PXD2A 4388 -SH3PXD2A-AS1 5 -SH3PXD2B 2315 -SH3RF1 1081 -SH3RF2 36 -SH3RF3 685 -SH3RF3-AS1 53 -SH3TC1 415 -SH3TC2 334 -SH3YL1 1494 -SHANK1 6016 -SHANK2 1516 -SHANK2-AS1 22 -SHANK2-AS3 2 -SHANK3 6923 -SHARPIN 1409 -SHB 1600 -SHBG 12 -SHC1 4612 -SHC2 4266 -SHC3 1890 -SHC4 292 -SHCBP1 31 -SHCBP1L 3 -SHD 201 -SHE 847 -SHF 765 -SHFM1 603 -SHH 85 -SHISA2 144 -SHISA3 75 -SHISA4 2027 -SHISA5 5488 -SHISA6 771 -SHISA7 2448 -SHISA8 18 -SHISA9 1241 -SHKBP1 1211 -SHMT1 553 -SHMT2 1602 -SHOC2 2869 -SHOX 0 -SHOX2 79 -SHPK 655 -SHPRH 288 -SHQ1 445 -SHROOM1 2704 -SHROOM2 414 -SHROOM3 929 -SHROOM4 1467 -SHTN1 3953 -SI 0 -SIAE 1947 -SIAH1 532 -SIAH2 1927 -SIAH3 66 -SIDT1 550 -SIDT2 1281 -SIGIRR 636 -SIGLEC1 215 -SIGLEC10 348 -SIGLEC11 25 -SIGLEC12 2 -SIGLEC14 24 -SIGLEC15 5 -SIGLEC16 40 -SIGLEC17P 2 -SIGLEC5 19 -SIGLEC6 0 -SIGLEC7 12 -SIGLEC8 374 -SIGLEC9 83 -SIGLECL1 0 -SIGMAR1 1605 -SIK1 815 -SIK2 2338 -SIK3 5390 -SIKE1 819 -SIL1 1177 -SIM1 11 -SIM2 257 -SIMC1 793 -SIN3A 1312 -SIN3B 6104 -SIPA1 1655 -SIPA1L1 9386 -SIPA1L2 3085 -SIPA1L3 1913 -SIRPA 8591 -SIRPB1 131 -SIRPB2 75 -SIRPD 5 -SIRPG 6 -SIRPG-AS1 0 -SIRT1 1057 -SIRT2 4054 -SIRT3 1175 -SIRT4 96 -SIRT5 700 -SIRT6 911 -SIRT7 1008 -SIT1 18 -SIVA1 812 -SIX1 140 -SIX2 119 -SIX3 6243 -SIX3-AS1 669 -SIX4 1524 -SIX5 1183 -SIX6 999 -SKA1 0 -SKA2 1470 -SKA3 9 -SKAP1 58 -SKAP2 935 -SKI 7314 -SKIDA1 129 -SKIL 2221 -SKINTL 5 -SKIV2L 2 -SKIV2L2 1294 -SKOR1 19 -SKOR2 69 -SKP1 7205 -SKP1P2 22 -SKP2 251 -SLA 340 -SLA2 49 -SLAIN1 2166 -SLAIN2 1476 -SLAMF1 7 -SLAMF6 27 -SLAMF7 41 -SLAMF8 429 -SLAMF9 1 -SLBP 2513 -SLC10A1 71 -SLC10A2 0 -SLC10A3 291 -SLC10A4 443 -SLC10A5 41 -SLC10A6 14 -SLC10A7 286 -SLC11A1 557 -SLC11A2 1294 -SLC12A1 28 -SLC12A2 1255 -SLC12A3 9 -SLC12A4 2115 -SLC12A5 3854 -SLC12A6 1739 -SLC12A7 263 -SLC12A8 146 -SLC12A9 1137 -SLC13A1 0 -SLC13A2 1 -SLC13A3 345 -SLC13A4 293 -SLC13A5 120 -SLC14A1 7008 -SLC14A2 16 -SLC14A2-AS1 9 -SLC15A1 8 -SLC15A2 893 -SLC15A3 1042 -SLC15A4 708 -SLC15A5 13 -SLC16A1 1916 -SLC16A1-AS1 66 -SLC16A10 40 -SLC16A11 90 -SLC16A12 91 -SLC16A12-AS1 1 -SLC16A13 61 -SLC16A14 423 -SLC16A2 2080 -SLC16A3 322 -SLC16A4 1096 -SLC16A5 160 -SLC16A6 43 -SLC16A7 208 -SLC16A8 152 -SLC16A9 1850 -SLC17A1 0 -SLC17A2 0 -SLC17A3 3 -SLC17A4 1 -SLC17A5 1068 -SLC17A6 538 -SLC17A7 67 -SLC17A8 23 -SLC17A9 386 -SLC18A1 4 -SLC18A2 991 -SLC18A3 146 -SLC18B1 670 -SLC19A1 275 -SLC19A2 322 -SLC19A3 411 -SLC1A1 1713 -SLC1A2 9271 -SLC1A3 32381 -SLC1A4 3879 -SLC1A5 1917 -SLC1A6 314 -SLC1A7 458 -SLC20A1 1035 -SLC20A2 1892 -SLC22A1 13 -SLC22A10 0 -SLC22A11 0 -SLC22A12 3 -SLC22A13 34 -SLC22A14 16 -SLC22A15 672 -SLC22A16 2 -SLC22A17 28685 -SLC22A18 3 -SLC22A18AS 3 -SLC22A2 16 -SLC22A20 55 -SLC22A23 2175 -SLC22A24 2 -SLC22A25 0 -SLC22A3 125 -SLC22A31 1 -SLC22A4 223 -SLC22A5 625 -SLC22A6 49 -SLC22A7 26 -SLC22A8 2 -SLC22A9 2 -SLC23A1 42 -SLC23A2 3001 -SLC23A3 86 -SLC24A1 394 -SLC24A2 1533 -SLC24A3 1099 -SLC24A4 900 -SLC24A5 40 -SLC25A1 3075 -SLC25A10 143 -SLC25A11 1748 -SLC25A12 1407 -SLC25A13 314 -SLC25A14 807 -SLC25A15 205 -SLC25A16 266 -SLC25A17 680 -SLC25A18 2967 -SLC25A19 84 -SLC25A2 5 -SLC25A20 543 -SLC25A21 29 -SLC25A21-AS1 79 -SLC25A22 2560 -SLC25A23 5923 -SLC25A24 405 -SLC25A25 2015 -SLC25A25-AS1 731 -SLC25A26 282 -SLC25A27 1397 -SLC25A28 2117 -SLC25A29 3615 -SLC25A3 3850 -SLC25A30 802 -SLC25A30-AS1 20 -SLC25A31 6 -SLC25A32 514 -SLC25A33 542 -SLC25A34 265 -SLC25A35 122 -SLC25A36 2198 -SLC25A37 1062 -SLC25A38 1102 -SLC25A39 2625 -SLC25A3P1 0 -SLC25A4 3744 -SLC25A40 334 -SLC25A41 176 -SLC25A42 1553 -SLC25A43 458 -SLC25A44 1529 -SLC25A45 87 -SLC25A46 1568 -SLC25A47 3 -SLC25A48 259 -SLC25A5 1704 -SLC25A5-AS1 80 -SLC25A51 372 -SLC25A51P1 0 -SLC25A52 6 -SLC25A53 150 -SLC25A6 2 -SLC26A1 166 -SLC26A10 193 -SLC26A11 3445 -SLC26A2 1224 -SLC26A3 1 -SLC26A4 23 -SLC26A4-AS1 59 -SLC26A5 23 -SLC26A6 626 -SLC26A7 60 -SLC26A8 134 -SLC26A9 21 -SLC27A1 2443 -SLC27A2 61 -SLC27A3 0 -SLC27A4 1645 -SLC27A5 338 -SLC27A6 3432 -SLC28A1 5 -SLC28A2 0 -SLC28A3 26 -SLC29A1 511 -SLC29A2 675 -SLC29A3 227 -SLC29A4 1346 -SLC2A1 3079 -SLC2A1-AS1 48 -SLC2A10 419 -SLC2A11 160 -SLC2A12 565 -SLC2A13 1278 -SLC2A14 28 -SLC2A2 1 -SLC2A3 2275 -SLC2A4 47 -SLC2A4RG 1466 -SLC2A5 649 -SLC2A6 591 -SLC2A7 0 -SLC2A8 611 -SLC2A9 80 -SLC30A1 293 -SLC30A10 117 -SLC30A2 0 -SLC30A3 12 -SLC30A4 174 -SLC30A5 1008 -SLC30A6 564 -SLC30A7 798 -SLC30A8 4 -SLC30A9 1846 -SLC31A1 540 -SLC31A2 464 -SLC32A1 1430 -SLC33A1 1209 -SLC34A1 0 -SLC34A2 10 -SLC34A3 88 -SLC35A1 709 -SLC35A2 588 -SLC35A3 427 -SLC35A4 1363 -SLC35A5 1360 -SLC35B1 1092 -SLC35B2 499 -SLC35B3 420 -SLC35B4 1502 -SLC35C1 783 -SLC35C2 598 -SLC35D1 1633 -SLC35D2 417 -SLC35D3 89 -SLC35E1 2234 -SLC35E2 1190 -SLC35E2B 2908 -SLC35E3 164 -SLC35E4 281 -SLC35F1 1090 -SLC35F2 410 -SLC35F3 262 -SLC35F4 36 -SLC35F5 875 -SLC35F6 1624 -SLC35G1 24 -SLC35G2 1076 -SLC35G3 4 -SLC35G4 0 -SLC35G5 17 -SLC35G6 23 -SLC36A1 492 -SLC36A2 0 -SLC36A3 0 -SLC36A4 1086 -SLC37A1 971 -SLC37A2 177 -SLC37A3 612 -SLC37A4 283 -SLC38A1 5888 -SLC38A10 4687 -SLC38A11 75 -SLC38A2 9001 -SLC38A3 571 -SLC38A4 20 -SLC38A5 546 -SLC38A6 419 -SLC38A7 949 -SLC38A8 34 -SLC38A9 264 -SLC39A1 2196 -SLC39A10 1605 -SLC39A11 452 -SLC39A12 268 -SLC39A12-AS1 6 -SLC39A13 1353 -SLC39A14 3160 -SLC39A2 4 -SLC39A3 777 -SLC39A4 185 -SLC39A5 10 -SLC39A6 2405 -SLC39A7 0 -SLC39A8 636 -SLC39A9 1330 -SLC3A1 6 -SLC3A2 10731 -SLC40A1 1615 -SLC41A1 3223 -SLC41A2 436 -SLC41A3 2163 -SLC43A1 149 -SLC43A2 164 -SLC43A3 531 -SLC44A1 4792 -SLC44A2 3669 -SLC44A3 399 -SLC44A4 0 -SLC44A5 259 -SLC45A1 623 -SLC45A2 4 -SLC45A3 199 -SLC45A4 906 -SLC46A1 466 -SLC46A2 24 -SLC46A3 493 -SLC47A1 754 -SLC47A2 426 -SLC48A1 2676 -SLC4A1 12 -SLC4A10 836 -SLC4A11 322 -SLC4A1AP 837 -SLC4A2 2753 -SLC4A3 4042 -SLC4A4 6676 -SLC4A5 249 -SLC4A7 851 -SLC4A8 1432 -SLC4A9 32 -SLC50A1 631 -SLC51A 44 -SLC51B 93 -SLC52A1 50 -SLC52A2 1045 -SLC52A3 295 -SLC5A1 6 -SLC5A10 23 -SLC5A11 101 -SLC5A12 10 -SLC5A2 27 -SLC5A3 11146 -SLC5A4 51 -SLC5A5 13 -SLC5A6 989 -SLC5A7 43 -SLC5A8 2 -SLC5A9 30 -SLC6A1 1859 -SLC6A1-AS1 14 -SLC6A10P 22 -SLC6A11 819 -SLC6A12 236 -SLC6A13 86 -SLC6A14 2 -SLC6A15 764 -SLC6A16 117 -SLC6A17 3628 -SLC6A18 0 -SLC6A19 0 -SLC6A2 2 -SLC6A20 182 -SLC6A3 38 -SLC6A4 35 -SLC6A5 0 -SLC6A6 1097 -SLC6A7 225 -SLC6A8 2850 -SLC6A9 1681 -SLC7A1 4238 -SLC7A10 177 -SLC7A11 4145 -SLC7A11-AS1 314 -SLC7A13 0 -SLC7A14 2565 -SLC7A2 1162 -SLC7A3 106 -SLC7A4 192 -SLC7A5 11314 -SLC7A5P1 9 -SLC7A5P2 110 -SLC7A6 1415 -SLC7A6OS 202 -SLC7A7 210 -SLC7A8 1222 -SLC7A9 96 -SLC8A1 730 -SLC8A1-AS1 22 -SLC8A2 2754 -SLC8A3 480 -SLC8B1 757 -SLC9A1 1345 -SLC9A2 66 -SLC9A3 85 -SLC9A3R1 1755 -SLC9A3R2 4670 -SLC9A4 1 -SLC9A5 356 -SLC9A6 6418 -SLC9A7 2963 -SLC9A7P1 132 -SLC9A8 1005 -SLC9A9 893 -SLC9A9-AS1 0 -SLC9B1 31 -SLC9B2 1651 -SLC9C1 1 -SLC9C2 94 -SLCO1A2 843 -SLCO1B1 2 -SLCO1B3 3 -SLCO1B7 1 -SLCO1C1 3232 -SLCO2A1 1006 -SLCO2B1 2488 -SLCO3A1 3480 -SLCO4A1 2469 -SLCO4A1-AS1 45 -SLCO4C1 23 -SLCO5A1 20 -SLCO6A1 0 -SLED1 23 -SLF1 539 -SLF2 2188 -SLFN11 1353 -SLFN12 252 -SLFN12L 14 -SLFN13 131 -SLFN14 0 -SLFN5 164 -SLFNL1 32 -SLFNL1-AS1 83 -SLIRP 742 -SLIT1 2182 -SLIT1-AS1 2 -SLIT2 3493 -SLIT2-IT1 0 -SLIT3 1577 -SLITRK1 779 -SLITRK2 1439 -SLITRK3 430 -SLITRK4 901 -SLITRK5 721 -SLITRK6 62 -SLK 2559 -SLMAP 2320 -SLMO1 650 -SLMO2 679 -SLMO2-ATP5E 3 -SLN 2 -SLPI 622 -SLTM 5631 -SLU7 2948 -SLURP1 1 -SLX1A 0 -SLX1A-SULT1A3 0 -SLX1B 0 -SLX1B-SULT1A4 0 -SLX4 671 -SLX4IP 70 -SMA4 61 -SMA5 17 -SMAD1 1641 -SMAD1-AS1 0 -SMAD1-AS2 13 -SMAD2 2799 -SMAD3 1659 -SMAD4 2316 -SMAD5 2122 -SMAD5-AS1 10 -SMAD6 870 -SMAD7 1022 -SMAD9 1628 -SMAGP 77 -SMAP1 2102 -SMAP2 2651 -SMARCA1 3927 -SMARCA2 5361 -SMARCA4 5788 -SMARCA5 3401 -SMARCA5-AS1 4 -SMARCAD1 1371 -SMARCAL1 736 -SMARCB1 1 -SMARCC1 3044 -SMARCC2 10947 -SMARCD1 1279 -SMARCD2 907 -SMARCD3 4567 -SMARCE1 2089 -SMC1A 2777 -SMC1B 22 -SMC2 574 -SMC2-AS1 0 -SMC3 2107 -SMC4 597 -SMC5 1377 -SMC5-AS1 29 -SMC6 1438 -SMCHD1 1948 -SMCO1 11 -SMCO2 14 -SMCO3 3 -SMCO4 633 -SMCP 1 -SMCR2 1 -SMCR5 24 -SMCR8 1865 -SMDT1 0 -SMG1 5746 -SMG1P1 53 -SMG1P2 38 -SMG1P3 207 -SMG1P5 24 -SMG1P7 465 -SMG5 5650 -SMG6 3756 -SMG7 3041 -SMG7-AS1 15 -SMG8 596 -SMG9 1894 -SMIM1 40 -SMIM10 663 -SMIM10L1 136 -SMIM10L2A 1609 -SMIM10L2B 1538 -SMIM11 5 -SMIM12 1044 -SMIM13 1397 -SMIM14 895 -SMIM15 1132 -SMIM17 325 -SMIM18 88 -SMIM19 498 -SMIM2 0 -SMIM2-AS1 24 -SMIM2-IT1 1 -SMIM20 606 -SMIM21 0 -SMIM22 6 -SMIM23 0 -SMIM24 47 -SMIM3 489 -SMIM4 204 -SMIM5 165 -SMIM6 8 -SMIM7 1211 -SMIM8 368 -SMIM9 0 -SMKR1 94 -SMLR1 13 -SMN1 0 -SMN2 11 -SMNDC1 1175 -SMO 1712 -SMOC1 2284 -SMOC2 310 -SMOX 2972 -SMPD1 1797 -SMPD2 203 -SMPD3 1081 -SMPD4 2627 -SMPDL3A 276 -SMPDL3B 21 -SMPX 8 -SMR3A 0 -SMR3B 0 -SMS 843 -SMTN 2211 -SMTNL1 50 -SMTNL2 14 -SMU1 1637 -SMUG1 468 -SMURF1 1671 -SMURF2 999 -SMYD1 3 -SMYD2 587 -SMYD3 341 -SMYD4 579 -SMYD5 1062 -SNAI1 253 -SNAI2 45 -SNAI3 145 -SNAI3-AS1 239 -SNAP23 2027 -SNAP25 9747 -SNAP25-AS1 70 -SNAP29 1262 -SNAP47 918 -SNAP91 3542 -SNAPC1 481 -SNAPC2 576 -SNAPC3 1581 -SNAPC4 960 -SNAPC5 158 -SNAPIN 771 -SNAR-A1 0 -SNAR-A10 0 -SNAR-A11 0 -SNAR-A12 0 -SNAR-A13 0 -SNAR-A14 0 -SNAR-A2 0 -SNAR-A3 0 -SNAR-A4 0 -SNAR-A5 0 -SNAR-A6 0 -SNAR-A7 0 -SNAR-A8 0 -SNAR-A9 0 -SNAR-B1 0 -SNAR-B2 0 -SNAR-C1 0 -SNAR-C2 0 -SNAR-C3 0 -SNAR-C4 0 -SNAR-C5 0 -SNAR-D 0 -SNAR-E 2 -SNAR-F 1 -SNAR-G1 2 -SNAR-G2 0 -SNAR-H 0 -SNAR-I 0 -SNCA 1783 -SNCA-AS1 1 -SNCAIP 256 -SNCB 2829 -SNCG 8748 -SND1 3974 -SND1-IT1 109 -SNED1 2410 -SNF8 1204 -SNHG1 1079 -SNHG10 151 -SNHG11 238 -SNHG12 362 -SNHG15 298 -SNHG16 754 -SNHG17 374 -SNHG18 125 -SNHG19 208 -SNHG20 192 -SNHG21 105 -SNHG22 5 -SNHG24 89 -SNHG25 23 -SNHG3 482 -SNHG4 26 -SNHG5 903 -SNHG6 1674 -SNHG7 2136 -SNHG8 877 -SNHG9 186 -SNIP1 699 -SNN 4936 -SNORA1 3 -SNORA10 7 -SNORA11 1 -SNORA11B 0 -SNORA11C 0 -SNORA11D 0 -SNORA11E 0 -SNORA12 1 -SNORA13 3 -SNORA14A 0 -SNORA14B 20 -SNORA15 2 -SNORA16A 8 -SNORA16B 8 -SNORA17 0 -SNORA18 8 -SNORA19 1 -SNORA20 30 -SNORA21 3 -SNORA22 3 -SNORA23 2 -SNORA24 5 -SNORA25 10 -SNORA26 1 -SNORA27 3 -SNORA28 4 -SNORA29 17 -SNORA2A 0 -SNORA2B 0 -SNORA30 0 -SNORA31 7 -SNORA32 1 -SNORA33 3 -SNORA34 0 -SNORA35 0 -SNORA36A 0 -SNORA36B 0 -SNORA36C 0 -SNORA37 1 -SNORA38 0 -SNORA38B 0 -SNORA4 48 -SNORA40 2 -SNORA41 3 -SNORA43 0 -SNORA44 7 -SNORA45A 1 -SNORA45B 3 -SNORA46 0 -SNORA47 2 -SNORA48 9 -SNORA49 0 -SNORA51 3 -SNORA52 6 -SNORA53 4 -SNORA54 0 -SNORA55 0 -SNORA56 0 -SNORA57 9 -SNORA58 1 -SNORA59A 0 -SNORA59B 0 -SNORA5A 3 -SNORA5B 0 -SNORA5C 2 -SNORA6 3 -SNORA60 1 -SNORA61 22 -SNORA62 1 -SNORA63 20 -SNORA64 14 -SNORA65 6 -SNORA66 6 -SNORA67 26 -SNORA68 0 -SNORA69 0 -SNORA70 22 -SNORA70B 1 -SNORA70C 1 -SNORA70D 1 -SNORA70E 0 -SNORA70F 1 -SNORA70G 2 -SNORA71A 0 -SNORA71B 1 -SNORA71C 0 -SNORA71D 0 -SNORA71E 0 -SNORA72 6 -SNORA73A 7 -SNORA73B 3 -SNORA74A 2 -SNORA74B 2 -SNORA75 2 -SNORA76A 0 -SNORA76C 4 -SNORA77 80 -SNORA78 2 -SNORA79 0 -SNORA7A 0 -SNORA7B 8 -SNORA8 12 -SNORA80A 0 -SNORA80B 2 -SNORA80E 3 -SNORA81 19 -SNORA84 1 -SNORA9 0 -SNORD10 3 -SNORD100 0 -SNORD101 0 -SNORD102 2 -SNORD103A 0 -SNORD103B 0 -SNORD104 11 -SNORD105 1 -SNORD105B 0 -SNORD107 0 -SNORD108 0 -SNORD109A 0 -SNORD109B 0 -SNORD11 3 -SNORD110 6 -SNORD111 0 -SNORD111B 0 -SNORD112 0 -SNORD113-1 0 -SNORD113-2 0 -SNORD113-3 0 -SNORD113-4 2 -SNORD113-5 0 -SNORD113-6 0 -SNORD113-7 0 -SNORD113-8 0 -SNORD113-9 0 -SNORD114-1 1 -SNORD114-10 2 -SNORD114-11 0 -SNORD114-12 0 -SNORD114-13 0 -SNORD114-14 1 -SNORD114-15 0 -SNORD114-16 0 -SNORD114-17 0 -SNORD114-18 0 -SNORD114-19 0 -SNORD114-2 6 -SNORD114-20 0 -SNORD114-21 0 -SNORD114-22 0 -SNORD114-23 0 -SNORD114-24 1 -SNORD114-25 0 -SNORD114-26 0 -SNORD114-27 0 -SNORD114-28 0 -SNORD114-29 0 -SNORD114-3 0 -SNORD114-30 1 -SNORD114-31 0 -SNORD114-4 7 -SNORD114-5 0 -SNORD114-6 1 -SNORD114-7 1 -SNORD114-8 0 -SNORD114-9 0 -SNORD115-1 0 -SNORD115-10 0 -SNORD115-11 0 -SNORD115-12 0 -SNORD115-13 0 -SNORD115-14 0 -SNORD115-15 0 -SNORD115-16 0 -SNORD115-17 0 -SNORD115-18 0 -SNORD115-19 0 -SNORD115-2 0 -SNORD115-20 0 -SNORD115-21 1 -SNORD115-22 0 -SNORD115-23 0 -SNORD115-24 0 -SNORD115-25 0 -SNORD115-26 0 -SNORD115-27 0 -SNORD115-28 0 -SNORD115-29 0 -SNORD115-3 0 -SNORD115-30 0 -SNORD115-31 0 -SNORD115-32 0 -SNORD115-33 0 -SNORD115-34 0 -SNORD115-35 0 -SNORD115-36 0 -SNORD115-37 0 -SNORD115-38 0 -SNORD115-39 0 -SNORD115-4 0 -SNORD115-40 0 -SNORD115-41 0 -SNORD115-42 0 -SNORD115-43 0 -SNORD115-44 0 -SNORD115-45 1 -SNORD115-46 1 -SNORD115-47 0 -SNORD115-48 0 -SNORD115-5 0 -SNORD115-6 0 -SNORD115-7 0 -SNORD115-8 0 -SNORD115-9 0 -SNORD116-1 0 -SNORD116-10 0 -SNORD116-11 0 -SNORD116-12 0 -SNORD116-13 1 -SNORD116-14 0 -SNORD116-15 1 -SNORD116-16 0 -SNORD116-17 0 -SNORD116-18 0 -SNORD116-19 0 -SNORD116-2 0 -SNORD116-20 0 -SNORD116-21 1 -SNORD116-22 0 -SNORD116-23 3 -SNORD116-24 0 -SNORD116-25 0 -SNORD116-26 0 -SNORD116-27 5 -SNORD116-28 3 -SNORD116-29 1 -SNORD116-3 0 -SNORD116-30 1 -SNORD116-4 7 -SNORD116-5 0 -SNORD116-6 0 -SNORD116-7 0 -SNORD116-8 0 -SNORD116-9 0 -SNORD117 0 -SNORD118 0 -SNORD119 1 -SNORD11B 2 -SNORD12 1 -SNORD121A 0 -SNORD121B 0 -SNORD123 0 -SNORD124 9 -SNORD125 0 -SNORD126 0 -SNORD127 0 -SNORD12B 0 -SNORD12C 1 -SNORD13 0 -SNORD14A 2 -SNORD14B 0 -SNORD14C 60 -SNORD14D 116 -SNORD14E 16 -SNORD15A 0 -SNORD15B 0 -SNORD16 6 -SNORD17 9 -SNORD18A 1 -SNORD18B 0 -SNORD18C 0 -SNORD19 0 -SNORD19B 2 -SNORD1A 0 -SNORD1B 0 -SNORD1C 0 -SNORD2 1 -SNORD20 0 -SNORD21 7 -SNORD22 20 -SNORD23 1 -SNORD24 1 -SNORD25 1 -SNORD26 1 -SNORD27 1 -SNORD28 3 -SNORD29 0 -SNORD30 0 -SNORD31 0 -SNORD32A 1 -SNORD32B 0 -SNORD33 2 -SNORD34 0 -SNORD35A 0 -SNORD35B 1 -SNORD36A 11 -SNORD36B 0 -SNORD36C 1 -SNORD37 0 -SNORD38A 5 -SNORD38B 0 -SNORD3A 13 -SNORD3B-1 0 -SNORD3B-2 0 -SNORD3C 0 -SNORD3D 0 -SNORD41 6 -SNORD42A 2 -SNORD42B 0 -SNORD43 0 -SNORD44 0 -SNORD45A 1 -SNORD45B 0 -SNORD45C 0 -SNORD46 0 -SNORD47 8 -SNORD48 0 -SNORD49A 1 -SNORD49B 0 -SNORD4A 4 -SNORD4B 4 -SNORD5 4 -SNORD50A 1 -SNORD50B 0 -SNORD51 0 -SNORD52 0 -SNORD53 0 -SNORD54 8 -SNORD55 8 -SNORD56 3 -SNORD56B 0 -SNORD57 5 -SNORD58A 1 -SNORD58B 0 -SNORD58C 10 -SNORD59A 15 -SNORD59B 0 -SNORD6 1 -SNORD60 1 -SNORD61 1 -SNORD62A 0 -SNORD62B 0 -SNORD63 30 -SNORD64 0 -SNORD65 4 -SNORD66 1 -SNORD67 3 -SNORD68 7 -SNORD69 0 -SNORD7 0 -SNORD70 0 -SNORD71 0 -SNORD72 0 -SNORD73A 0 -SNORD74 1 -SNORD75 0 -SNORD76 1 -SNORD77 0 -SNORD78 0 -SNORD79 4 -SNORD8 1 -SNORD80 0 -SNORD81 0 -SNORD82 3 -SNORD83A 0 -SNORD83B 1 -SNORD84 0 -SNORD85 0 -SNORD86 0 -SNORD87 0 -SNORD88A 0 -SNORD88B 0 -SNORD88C 1 -SNORD89 9 -SNORD9 0 -SNORD90 0 -SNORD91A 0 -SNORD91B 1 -SNORD92 0 -SNORD93 0 -SNORD94 4 -SNORD95 0 -SNORD96A 0 -SNORD96B 0 -SNORD97 10 -SNORD98 0 -SNORD99 2 -SNPH 4224 -SNRK 720 -SNRK-AS1 57 -SNRNP200 4644 -SNRNP25 1202 -SNRNP27 1875 -SNRNP35 695 -SNRNP40 489 -SNRNP48 1128 -SNRNP70 10309 -SNRPA 1867 -SNRPA1 191 -SNRPB 1084 -SNRPB2 1464 -SNRPC 805 -SNRPD1 1022 -SNRPD2 2072 -SNRPD2P2 2 -SNRPD3 3109 -SNRPE 342 -SNRPF 568 -SNRPG 259 -SNRPN 229 -SNTA1 4556 -SNTB1 2223 -SNTB2 2191 -SNTG1 288 -SNTG2 6 -SNTN 1 -SNU13 4577 -SNUPN 786 -SNURF 2 -SNW1 1814 -SNX1 3726 -SNX10 1747 -SNX11 640 -SNX12 1341 -SNX13 1425 -SNX14 1584 -SNX15 0 -SNX16 539 -SNX17 2265 -SNX18 1450 -SNX19 3394 -SNX2 1802 -SNX20 53 -SNX21 1060 -SNX22 428 -SNX24 626 -SNX25 983 -SNX27 3738 -SNX29 854 -SNX29P1 16 -SNX29P2 19 -SNX3 9939 -SNX30 1375 -SNX31 36 -SNX32 361 -SNX33 780 -SNX4 683 -SNX5 1880 -SNX6 1101 -SNX7 1087 -SNX8 1093 -SNX9 2179 -SOAT1 1105 -SOAT2 5 -SOBP 3011 -SOCS1 113 -SOCS2 675 -SOCS2-AS1 18 -SOCS3 5586 -SOCS4 1414 -SOCS5 1028 -SOCS6 1110 -SOCS7 63 -SOD1 10402 -SOD2 4109 -SOD3 2481 -SOGA1 3225 -SOGA3 843 -SOHLH1 39 -SOHLH2 1 -SON 12388 -SORBS1 13085 -SORBS2 1739 -SORBS3 4172 -SORCS1 786 -SORCS2 556 -SORCS3 1059 -SORCS3-AS1 5 -SORD 225 -SORL1 6568 -SORT1 5779 -SOS1 3424 -SOS2 1593 -SOST 2 -SOSTDC1 94 -SOWAHA 805 -SOWAHB 13 -SOWAHC 582 -SOWAHD 44 -SOX1 769 -SOX10 2683 -SOX11 482 -SOX12 1785 -SOX13 1216 -SOX14 138 -SOX15 554 -SOX17 89 -SOX18 259 -SOX2 10574 -SOX2-OT 2404 -SOX21 610 -SOX21-AS1 288 -SOX3 291 -SOX30 18 -SOX4 1179 -SOX5 461 -SOX6 1421 -SOX7 398 -SOX8 1760 -SOX9 7164 -SOX9-AS1 195 -SP1 2590 -SP100 1401 -SP110 688 -SP140 73 -SP140L 238 -SP2 915 -SP2-AS1 62 -SP3 1964 -SP4 568 -SP5 66 -SP6 40 -SP7 4 -SP8 1 -SP9 6 -SPA17 314 -SPACA1 0 -SPACA3 0 -SPACA4 32 -SPACA5 0 -SPACA5B 0 -SPACA6P 1079 -SPACA6P-AS 272 -SPACA7 0 -SPAG1 670 -SPAG11A 0 -SPAG11B 0 -SPAG16 706 -SPAG17 1683 -SPAG4 137 -SPAG5 629 -SPAG5-AS1 98 -SPAG6 1005 -SPAG7 1088 -SPAG8 603 -SPAG9 6566 -SPAM1 0 -SPANXA1 0 -SPANXA2 0 -SPANXA2-OT1 6 -SPANXB1 0 -SPANXC 0 -SPANXD 0 -SPANXN1 0 -SPANXN2 0 -SPANXN3 0 -SPANXN4 0 -SPANXN5 0 -SPARC 87896 -SPARCL1 57327 -SPAST 695 -SPATA1 44 -SPATA12 8 -SPATA13 2969 -SPATA13-AS1 3 -SPATA16 0 -SPATA17 133 -SPATA17-AS1 0 -SPATA18 1792 -SPATA19 0 -SPATA2 1621 -SPATA20 2366 -SPATA21 5 -SPATA22 23 -SPATA24 68 -SPATA25 76 -SPATA2L 467 -SPATA3 0 -SPATA3-AS1 3 -SPATA31A1 0 -SPATA31A3 0 -SPATA31A5 0 -SPATA31A6 0 -SPATA31A7 0 -SPATA31C1 5 -SPATA31C2 2 -SPATA31D1 0 -SPATA31D3 0 -SPATA31D4 0 -SPATA31D5P 0 -SPATA31E1 2 -SPATA32 5 -SPATA33 529 -SPATA4 43 -SPATA41 71 -SPATA42 0 -SPATA45 9 -SPATA5 344 -SPATA5L1 251 -SPATA6 745 -SPATA6L 422 -SPATA7 367 -SPATA8 0 -SPATA8-AS1 0 -SPATA9 20 -SPATC1 42 -SPATC1L 0 -SPATS1 12 -SPATS2 1336 -SPATS2L 6724 -SPC24 3 -SPC25 0 -SPCS1 1565 -SPCS2 676 -SPCS3 1676 -SPDEF 12 -SPDL1 297 -SPDYA 83 -SPDYC 1 -SPDYE1 59 -SPDYE2 0 -SPDYE2B 0 -SPDYE3 42 -SPDYE4 0 -SPDYE5 27 -SPDYE6 33 -SPDYE7P 5 -SPDYE8P 0 -SPECC1 1936 -SPECC1L 3267 -SPECC1L-ADORA2A 14 -SPEF1 465 -SPEF2 653 -SPEG 3080 -SPEM1 0 -SPEN 8549 -SPERT 0 -SPESP1 101 -SPG11 1843 -SPG20 4953 -SPG20-AS1 37 -SPG21 2085 -SPG7 2489 -SPHAR 0 -SPHK1 412 -SPHK2 2588 -SPHKAP 621 -SPI1 1033 -SPIB 5 -SPIC 0 -SPICE1 506 -SPIDR 1742 -SPIN1 5756 -SPIN2A 6 -SPIN2B 124 -SPIN3 620 -SPIN4 233 -SPINK1 0 -SPINK13 1 -SPINK14 0 -SPINK2 21 -SPINK4 3 -SPINK5 38 -SPINK6 3 -SPINK7 0 -SPINK8 17 -SPINK9 6 -SPINT1 115 -SPINT2 4237 -SPINT3 0 -SPINT4 0 -SPIRE1 2801 -SPIRE2 834 -SPN 349 -SPNS1 870 -SPNS2 1577 -SPNS3 11 -SPO11 0 -SPOCD1 42 -SPOCK1 2970 -SPOCK2 22553 -SPOCK3 1575 -SPON1 3166 -SPON2 240 -SPOP 3451 -SPOPL 1199 -SPP1 5666 -SPP2 0 -SPPL2A 362 -SPPL2B 1616 -SPPL2C 1 -SPPL3 1947 -SPR 1990 -SPRED1 2108 -SPRED2 1732 -SPRED3 1752 -SPRN 566 -SPRNP1 55 -SPRR1A 0 -SPRR1B 0 -SPRR2A 0 -SPRR2B 0 -SPRR2C 0 -SPRR2D 1 -SPRR2E 0 -SPRR2F 1 -SPRR2G 1 -SPRR3 0 -SPRR4 0 -SPRTN 243 -SPRY1 684 -SPRY2 2291 -SPRY3 0 -SPRY4 2275 -SPRY4-IT1 38 -SPRYD3 4664 -SPRYD4 281 -SPRYD7 932 -SPSB1 633 -SPSB2 250 -SPSB3 1717 -SPSB4 41 -SPTA1 1 -SPTAN1 29559 -SPTB 1837 -SPTBN1 47082 -SPTBN2 4601 -SPTBN4 5027 -SPTBN5 373 -SPTLC1 1793 -SPTLC2 2230 -SPTLC3 683 -SPTSSA 1272 -SPTSSB 96 -SPTY2D1 735 -SPTY2D1-AS1 24 -SPX 207 -SPZ1 1 -SQLE 1274 -SQRDL 832 -SQSTM1 16557 -SRA1 1321 -SRBD1 270 -SRC 2387 -SRCAP 5922 -SRCIN1 0 -SRD5A1 301 -SRD5A1P1 7 -SRD5A2 3 -SRD5A3 238 -SRD5A3-AS1 19 -SREBF1 2074 -SREBF2 8423 -SREK1 7178 -SREK1IP1 1142 -SRF 1769 -SRFBP1 231 -SRGAP1 2326 -SRGAP2 3726 -SRGAP2-AS1 5 -SRGAP2B 438 -SRGAP2C 86 -SRGAP2D 215 -SRGAP3 2719 -SRGAP3-AS3 40 -SRGN 1311 -SRI 4006 -SRL 127 -SRM 1804 -SRMS 4 -SRP14 6825 -SRP14-AS1 670 -SRP19 2066 -SRP54 1283 -SRP68 2692 -SRP72 2409 -SRP9 3770 -SRPK1 1100 -SRPK2 5488 -SRPK3 225 -SRPR 3140 -SRPRB 1363 -SRPX 1715 -SRPX2 296 -SRR 229 -SRRD 285 -SRRM1 3128 -SRRM2 35079 -SRRM2-AS1 8 -SRRM3 2107 -SRRM4 753 -SRRM5 179 -SRRT 4762 -SRSF1 6632 -SRSF10 2871 -SRSF11 7157 -SRSF12 390 -SRSF2 2744 -SRSF3 4319 -SRSF4 4824 -SRSF5 6791 -SRSF6 5828 -SRSF7 2680 -SRSF8 1957 -SRSF9 1315 -SRXN1 1151 -SRY 0 -SS18 2232 -SS18L1 1379 -SS18L2 481 -SSB 3738 -SSBP1 618 -SSBP2 2271 -SSBP3 3756 -SSBP3-AS1 159 -SSBP4 3847 -SSC4D 49 -SSC5D 516 -SSFA2 9321 -SSH1 4422 -SSH2 1595 -SSH3 1280 -SSMEM1 4 -SSNA1 908 -SSPN 2083 -SSPO 278 -SSR1 3845 -SSR2 2093 -SSR3 3670 -SSR4 3546 -SSR4P1 58 -SSRP1 3853 -SSSCA1 184 -SSSCA1-AS1 80 -SST 9746 -SSTR1 1054 -SSTR2 630 -SSTR3 361 -SSTR4 4 -SSTR5 49 -SSTR5-AS1 11 -SSU72 3741 -SSUH2 14 -SSX1 0 -SSX2 0 -SSX2B 0 -SSX2IP 924 -SSX3 0 -SSX4 0 -SSX4B 0 -SSX5 1 -SSX6 0 -SSX7 0 -SSX8 0 -SSX9 0 -ST13 5522 -ST13P4 8 -ST14 192 -ST18 520 -ST20 154 -ST20-AS1 70 -ST20-MTHFS 3 -ST3GAL1 2850 -ST3GAL2 1232 -ST3GAL3 1006 -ST3GAL4 481 -ST3GAL4-AS1 34 -ST3GAL5 2654 -ST3GAL5-AS1 22 -ST3GAL6 947 -ST3GAL6-AS1 78 -ST5 2731 -ST6GAL1 3041 -ST6GAL2 151 -ST6GALNAC1 76 -ST6GALNAC2 317 -ST6GALNAC3 384 -ST6GALNAC4 538 -ST6GALNAC5 97 -ST6GALNAC6 5968 -ST7 913 -ST7-AS1 19 -ST7-AS2 18 -ST7-OT3 18 -ST7-OT4 14 -ST7L 629 -ST8SIA1 2246 -ST8SIA2 89 -ST8SIA3 2745 -ST8SIA4 561 -ST8SIA5 174 -ST8SIA6 82 -ST8SIA6-AS1 3 -STAB1 2914 -STAB2 44 -STAC 280 -STAC2 368 -STAC3 99 -STAG1 1263 -STAG2 4399 -STAG3 135 -STAG3L1 13 -STAG3L2 126 -STAG3L3 107 -STAG3L4 292 -STAG3L5P 5 -STAG3L5P-PVRIG2P-PILRB 1035 -STAM 910 -STAM-AS1 47 -STAM2 1424 -STAMBP 1680 -STAMBPL1 339 -STAP1 1 -STAP2 72 -STAR 315 -STARD10 1802 -STARD13 803 -STARD13-AS 1 -STARD3 2523 -STARD3NL 1979 -STARD4 849 -STARD4-AS1 35 -STARD5 82 -STARD6 0 -STARD7 5535 -STARD7-AS1 113 -STARD8 731 -STARD9 1261 -STAT1 3467 -STAT2 4375 -STAT3 10158 -STAT4 336 -STAT5A 930 -STAT5B 5712 -STAT6 4433 -STATH 0 -STAU1 3956 -STAU2 1511 -STAU2-AS1 12 -STBD1 65 -STC1 1228 -STC2 96 -STEAP1 82 -STEAP1B 19 -STEAP2 819 -STEAP2-AS1 1 -STEAP3 879 -STEAP3-AS1 13 -STEAP4 242 -STH 1 -STIL 104 -STIM1 3703 -STIM2 1225 -STIP1 21172 -STK10 587 -STK11 3098 -STK11IP 879 -STK16 431 -STK17A 1159 -STK17B 321 -STK19 51 -STK24 2822 -STK25 3998 -STK26 97 -STK3 509 -STK31 11 -STK32A 4891 -STK32B 206 -STK32C 624 -STK33 771 -STK35 1692 -STK36 2200 -STK38 1504 -STK38L 1807 -STK39 1914 -STK4 1713 -STK4-AS1 6 -STK40 3327 -STKLD1 95 -STMN1 10168 -STMN2 22703 -STMN3 7142 -STMN4 3036 -STMND1 35 -STOM 6691 -STOML1 884 -STOML2 1406 -STOML3 39 -STON1 2469 -STON1-GTF2A1L 26 -STON2 3639 -STOX1 774 -STOX2 1091 -STPG1 805 -STPG2 11 -STPG2-AS1 0 -STRA13 730 -STRA6 74 -STRA8 0 -STRADA 1475 -STRADB 478 -STRAP 3932 -STRBP 1189 -STRC 17 -STRIP1 1094 -STRIP2 396 -STRN 1309 -STRN3 1524 -STRN4 3551 -STS 643 -STT3A 2412 -STT3B 3047 -STUB1 1703 -STX10 1140 -STX11 168 -STX12 2514 -STX16 5881 -STX16-NPEPL1 25 -STX17 1370 -STX17-AS1 30 -STX18 775 -STX18-AS1 43 -STX18-IT1 0 -STX19 6 -STX1A 981 -STX1B 3658 -STX2 1253 -STX3 670 -STX4 1122 -STX5 1405 -STX6 1651 -STX7 2355 -STX8 764 -STXBP1 10840 -STXBP2 333 -STXBP3 1327 -STXBP4 553 -STXBP5 1660 -STXBP5-AS1 273 -STXBP5L 454 -STXBP6 478 -STYK1 58 -STYX 346 -STYXL1 588 -SUB1 2560 -SUCLA2 1099 -SUCLG1 1695 -SUCLG2 578 -SUCLG2-AS1 71 -SUCNR1 3 -SUCO 1412 -SUDS3 1763 -SUFU 912 -SUGCT 61 -SUGP1 1338 -SUGP2 4973 -SUGT1 1867 -SUGT1P1 73 -SUGT1P3 20 -SULF1 1191 -SULF2 2850 -SULT1A1 567 -SULT1A2 39 -SULT1A3 0 -SULT1A4 0 -SULT1B1 23 -SULT1C2 90 -SULT1C2P1 9 -SULT1C3 0 -SULT1C4 475 -SULT1E1 14 -SULT2A1 3 -SULT2B1 24 -SULT4A1 3111 -SULT6B1 0 -SUMF1 722 -SUMF2 1663 -SUMO1 2185 -SUMO1P1 0 -SUMO1P3 27 -SUMO2 1127 -SUMO3 3264 -SUMO4 66 -SUN1 3111 -SUN2 5689 -SUN3 5 -SUN5 0 -SUOX 828 -SUPT16H 2397 -SUPT20H 1463 -SUPT20HL1 1 -SUPT20HL2 0 -SUPT3H 376 -SUPT4H1 1257 -SUPT5H 7630 -SUPT6H 5909 -SUPT7L 3268 -SUPV3L1 661 -SURF1 1322 -SURF2 383 -SURF4 4688 -SURF6 2069 -SUSD1 527 -SUSD2 2427 -SUSD3 67 -SUSD4 1823 -SUSD5 813 -SUSD6 1682 -SUV39H1 311 -SUV39H2 312 -SUV420H1 1951 -SUV420H2 671 -SUZ12 879 -SUZ12P1 319 -SV2A 7648 -SV2B 762 -SV2C 1654 -SVBP 361 -SVEP1 139 -SVIL 2075 -SVIL-AS1 1331 -SVILP1 8 -SVIP 1033 -SVOP 1639 -SVOPL 6 -SWAP70 2470 -SWI5 540 -SWSAP1 59 -SWT1 509 -SYAP1 1349 -SYBU 3717 -SYCE1 194 -SYCE1L 57 -SYCE2 27 -SYCE3 12 -SYCN 1 -SYCP1 0 -SYCP2 232 -SYCP2L 35 -SYCP3 66 -SYDE1 1252 -SYDE2 235 -SYF2 2190 -SYK 563 -SYMPK 2985 -SYN1 9194 -SYN2 2851 -SYN3 115 -SYNC 179 -SYNCRIP 4269 -SYNDIG1 422 -SYNDIG1L 278 -SYNE1 15236 -SYNE1-AS1 1 -SYNE2 5027 -SYNE3 141 -SYNE4 141 -SYNGAP1 50 -SYNGR1 7059 -SYNGR2 1361 -SYNGR3 4139 -SYNGR4 9 -SYNJ1 3083 -SYNJ2 1197 -SYNJ2-IT1 1 -SYNJ2BP 2397 -SYNJ2BP-COX16 0 -SYNM 12946 -SYNPO 9199 -SYNPO2 3462 -SYNPO2L 48 -SYNPR 270 -SYNPR-AS1 0 -SYNRG 4 -SYP 16044 -SYP-AS1 80 -SYPL1 1425 -SYPL2 186 -SYS1 1521 -SYS1-DBNDD2 8 -SYT1 7285 -SYT10 214 -SYT11 9172 -SYT12 1155 -SYT13 2026 -SYT14 298 -SYT14P1 0 -SYT15 83 -SYT16 119 -SYT17 2164 -SYT2 198 -SYT3 648 -SYT4 3412 -SYT5 4875 -SYT6 720 -SYT7 1792 -SYT8 0 -SYT9 381 -SYTL1 78 -SYTL2 863 -SYTL3 136 -SYTL4 3515 -SYTL5 755 -SYVN1 3771 -SZRD1 3123 -SZT2 3293 -T 14 -TAAR1 0 -TAAR2 0 -TAAR3 6 -TAAR5 2 -TAAR6 1 -TAAR8 0 -TAAR9 0 -TAB1 1138 -TAB2 5921 -TAB3 849 -TAC1 3066 -TAC3 1116 -TAC4 11 -TACC1 8291 -TACC2 1588 -TACC3 318 -TACO1 607 -TACR1 103 -TACR2 29 -TACR3 49 -TACSTD2 2 -TADA1 404 -TADA2A 2 -TADA2B 1053 -TADA3 3354 -TAF1 1622 -TAF10 2147 -TAF11 649 -TAF12 716 -TAF13 628 -TAF15 1 -TAF1A 192 -TAF1A-AS1 44 -TAF1B 485 -TAF1C 3276 -TAF1D 928 -TAF1L 22 -TAF2 746 -TAF3 2122 -TAF4 155 -TAF4B 207 -TAF5 261 -TAF5L 463 -TAF6 3009 -TAF6L 652 -TAF7 4595 -TAF7L 15 -TAF8 868 -TAF9 0 -TAF9B 1246 -TAGAP 511 -TAGLN 5500 -TAGLN2 4243 -TAGLN3 4453 -TAL1 864 -TAL2 12 -TALDO1 2191 -TAMM41 163 -TANC1 1938 -TANC2 3105 -TANGO2 1408 -TANGO6 413 -TANK 1802 -TAOK1 4647 -TAOK2 5016 -TAOK3 7139 -TAP1 0 -TAP2 37 -TAPBP 11 -TAPBPL 628 -TAPT1 1623 -TAPT1-AS1 230 -TARBP1 660 -TARBP2 317 -TARDBP 4382 -TARID 18 -TARM1 0 -TARP 6 -TARS 4072 -TARS2 737 -TARSL2 1422 -TAS1R1 17 -TAS1R2 0 -TAS1R3 57 -TAS2R1 1 -TAS2R10 0 -TAS2R13 0 -TAS2R14 0 -TAS2R16 0 -TAS2R19 0 -TAS2R20 0 -TAS2R3 9 -TAS2R30 0 -TAS2R31 0 -TAS2R38 0 -TAS2R39 0 -TAS2R4 29 -TAS2R40 2 -TAS2R41 0 -TAS2R42 0 -TAS2R43 1 -TAS2R45 0 -TAS2R46 0 -TAS2R5 52 -TAS2R50 0 -TAS2R60 0 -TAS2R7 0 -TAS2R8 0 -TAS2R9 0 -TASP1 161 -TAT 9 -TAT-AS1 0 -TATDN1 255 -TATDN2 1945 -TATDN3 384 -TAX1BP1 5074 -TAX1BP3 14 -TAZ 1302 -TBATA 0 -TBC1D1 2160 -TBC1D10A 620 -TBC1D10B 2240 -TBC1D10C 91 -TBC1D12 907 -TBC1D13 1876 -TBC1D14 786 -TBC1D15 1415 -TBC1D16 2138 -TBC1D17 3742 -TBC1D19 335 -TBC1D2 662 -TBC1D20 2669 -TBC1D21 1 -TBC1D22A 855 -TBC1D22A-AS1 9 -TBC1D22B 635 -TBC1D23 877 -TBC1D24 1494 -TBC1D25 798 -TBC1D26 39 -TBC1D28 0 -TBC1D29 0 -TBC1D2B 1435 -TBC1D3 0 -TBC1D30 538 -TBC1D31 143 -TBC1D32 276 -TBC1D3B 0 -TBC1D3C 0 -TBC1D3E 0 -TBC1D3F 0 -TBC1D3H 0 -TBC1D3I 0 -TBC1D3K 0 -TBC1D3L 0 -TBC1D3P1-DHX40P1 90 -TBC1D3P2 82 -TBC1D3P5 0 -TBC1D4 1543 -TBC1D5 3036 -TBC1D7 203 -TBC1D8 694 -TBC1D8B 123 -TBC1D9 2071 -TBC1D9B 8081 -TBCA 1839 -TBCB 3981 -TBCC 448 -TBCCD1 408 -TBCD 916 -TBCE 411 -TBCEL 615 -TBCK 1441 -TBK1 1043 -TBKBP1 3014 -TBL1X 2769 -TBL1XR1 2260 -TBL1Y 0 -TBL2 713 -TBL3 694 -TBP 357 -TBPL1 1244 -TBPL2 0 -TBR1 7 -TBRG1 1968 -TBRG4 728 -TBX1 119 -TBX10 3 -TBX15 84 -TBX18 332 -TBX19 185 -TBX2 915 -TBX2-AS1 152 -TBX20 1 -TBX21 15 -TBX22 2 -TBX3 5178 -TBX4 1 -TBX5 13 -TBX5-AS1 12 -TBX6 205 -TBXA2R 84 -TBXAS1 406 -TC2N 4 -TCAF1 1548 -TCAF2 119 -TCAF2P1 16 -TCAIM 1080 -TCAM1P 10 -TCAP 501 -TCEA1 1620 -TCEA2 1909 -TCEA3 531 -TCEAL1 1482 -TCEAL2 5035 -TCEAL3 3992 -TCEAL4 5437 -TCEAL5 2386 -TCEAL6 1876 -TCEAL7 1764 -TCEAL8 1688 -TCEANC 258 -TCEANC2 763 -TCEB1 965 -TCEB2 3808 -TCEB3 1534 -TCEB3-AS1 17 -TCEB3B 9 -TCEB3C 0 -TCEB3CL 0 -TCEB3CL2 0 -TCERG1 1619 -TCERG1L 252 -TCERG1L-AS1 0 -TCF12 3637 -TCF15 29 -TCF19 0 -TCF20 0 -TCF21 19 -TCF23 0 -TCF24 48 -TCF25 5506 -TCF3 1730 -TCF4 5293 -TCF7 1379 -TCF7L1 1136 -TCF7L2 1244 -TCFL5 1529 -TCHH 46 -TCHHL1 0 -TCHP 968 -TCIRG1 1234 -TCL1A 0 -TCL1B 0 -TCL6 0 -TCN1 2 -TCN2 663 -TCOF1 2974 -TCONS_00029157 33 -TCP1 7536 -TCP10 0 -TCP10L 331 -TCP10L2 0 -TCP11 1 -TCP11L1 738 -TCP11L2 390 -TCP11X2 3 -TCTA 1426 -TCTE1 62 -TCTE3 0 -TCTEX1D1 532 -TCTEX1D2 254 -TCTEX1D4 50 -TCTN1 1883 -TCTN2 638 -TCTN3 797 -TDG 251 -TDGF1 37 -TDGF1P3 5 -TDH 24 -TDO2 0 -TDP1 209 -TDP2 1796 -TDRD1 21 -TDRD10 168 -TDRD12 5 -TDRD15 0 -TDRD3 609 -TDRD5 42 -TDRD6 494 -TDRD7 985 -TDRD9 336 -TDRG1 28 -TDRKH 355 -TDRP 1271 -TEAD1 3594 -TEAD2 825 -TEAD3 438 -TEAD4 240 -TEC 56 -TECPR1 2649 -TECPR2 2733 -TECR 2605 -TECRL 8 -TECTA 136 -TECTB 1 -TEDDM1 4 -TEF 1777 -TEFM 185 -TEK 841 -TEKT1 180 -TEKT2 312 -TEKT3 11 -TEKT4 82 -TEKT4P2 156 -TEKT5 13 -TELO2 1173 -TEN1 0 -TEN1-CDK3 79 -TENM1 880 -TENM2 1227 -TENM3 2955 -TENM4 1906 -TEP1 1966 -TEPP 31 -TERC 58 -TERF1 791 -TERF2 1768 -TERF2IP 10695 -TERT 4 -TES 290 -TESC 769 -TESC-AS1 0 -TESK1 3298 -TESK2 273 -TESPA1 14 -TET1 117 -TET2 1140 -TET2-AS1 6 -TET3 2062 -TEX10 412 -TEX101 0 -TEX11 1 -TEX12 1 -TEX13A 0 -TEX13B 0 -TEX14 119 -TEX15 252 -TEX19 2 -TEX2 5057 -TEX21P 36 -TEX22 48 -TEX26 267 -TEX26-AS1 10 -TEX261 2348 -TEX264 1120 -TEX28 0 -TEX29 43 -TEX30 231 -TEX33 0 -TEX35 0 -TEX36 0 -TEX36-AS1 0 -TEX37 0 -TEX38 2 -TEX40 30 -TEX41 2 -TEX43 6 -TEX9 269 -TF 3857 -TFAM 961 -TFAMP1 35 -TFAP2A 22 -TFAP2A-AS1 3 -TFAP2B 29 -TFAP2C 63 -TFAP2D 0 -TFAP2E 301 -TFAP4 398 -TFB1M 263 -TFB2M 183 -TFCP2 990 -TFCP2L1 136 -TFDP1 1384 -TFDP2 2346 -TFDP3 1 -TFE3 6782 -TFEB 762 -TFEC 228 -TFF1 0 -TFF2 0 -TFF3 18 -TFG 2885 -TFIP11 1141 -TFPI 100 -TFPI2 93 -TFPT 0 -TFR2 112 -TFRC 921 -TG 63 -TGDS 318 -TGFA 283 -TGFA-IT1 0 -TGFB1 2559 -TGFB1I1 412 -TGFB2 2190 -TGFB2-AS1 13 -TGFB2-OT1 0 -TGFB3 1271 -TGFBI 1058 -TGFBR1 824 -TGFBR2 3205 -TGFBR3 1757 -TGFBR3L 236 -TGFBRAP1 957 -TGIF1 1590 -TGIF2 356 -TGIF2-C20orf24 0 -TGIF2LX 0 -TGIF2LY 0 -TGM1 96 -TGM2 6065 -TGM3 12 -TGM4 3 -TGM5 16 -TGM6 0 -TGM7 0 -TGOLN2 9088 -TGS1 774 -TH 955 -TH2LCRR 7 -THADA 1105 -THAP1 485 -THAP10 243 -THAP11 1063 -THAP2 980 -THAP3 541 -THAP4 2137 -THAP5 931 -THAP6 495 -THAP7 788 -THAP7-AS1 185 -THAP8 374 -THAP9 364 -THAP9-AS1 919 -THBD 666 -THBS1 5941 -THBS2 1060 -THBS3 1460 -THBS4 2987 -THCAT155 11 -THCAT158 7 -THEG 4 -THEG5 0 -THEGL 23 -THEM4 792 -THEM5 22 -THEM6 745 -THEMIS 0 -THEMIS2 206 -THG1L 186 -THNSL1 394 -THNSL2 702 -THOC1 948 -THOC2 3231 -THOC3 104 -THOC5 718 -THOC6 458 -THOC7 951 -THOC7-AS1 7 -THOP1 2267 -THPO 29 -THRA 13479 -THRA1/BTR 0 -THRAP3 5357 -THRB 2637 -THRB-AS1 12 -THRIL 156 -THRSP 30 -THSD1 218 -THSD4 1191 -THSD4-AS1 3 -THSD4-AS2 1 -THSD7A 866 -THSD7B 68 -THTPA 928 -THUMPD1 1789 -THUMPD2 534 -THUMPD3 1725 -THUMPD3-AS1 1127 -THY1 10616 -THYN1 1504 -TIA1 1615 -TIAF1 123 -TIAL1 3045 -TIAM1 1642 -TIAM2 77 -TICAM1 1103 -TICAM2 5 -TICRR 48 -TIE1 1317 -TIFA 361 -TIFAB 0 -TIGAR 862 -TIGD1 167 -TIGD2 122 -TIGD3 93 -TIGD4 94 -TIGD5 0 -TIGD6 279 -TIGD7 783 -TIGIT 30 -TIMD4 8 -TIMELESS 427 -TIMM10 477 -TIMM10B 1284 -TIMM13 957 -TIMM17A 1073 -TIMM17B 668 -TIMM21 768 -TIMM22 0 -TIMM23 1016 -TIMM23B 144 -TIMM44 1520 -TIMM50 1032 -TIMM8A 91 -TIMM8B 493 -TIMM9 516 -TIMMDC1 1767 -TIMP1 4530 -TIMP2 15041 -TIMP3 15007 -TIMP4 206 -TINAG 5 -TINAGL1 1276 -TINCR 548 -TINF2 885 -TIPARP 2460 -TIPARP-AS1 9 -TIPIN 118 -TIPRL 1243 -TIRAP 242 -TISP43 0 -TJAP1 1716 -TJP1 145 -TJP2 4711 -TJP3 124 -TK1 46 -TK2 1463 -TKFC 535 -TKT 9578 -TKTL1 33 -TKTL2 1 -TLCD1 89 -TLCD2 0 -TLDC1 265 -TLDC2 132 -TLE1 1673 -TLE2 2096 -TLE3 3458 -TLE4 2199 -TLE6 218 -TLK1 1952 -TLK2 825 -TLL1 200 -TLL2 153 -TLN1 13302 -TLN2 2884 -TLR1 72 -TLR10 49 -TLR2 303 -TLR3 80 -TLR4 1667 -TLR5 287 -TLR6 99 -TLR7 340 -TLR8 24 -TLR8-AS1 0 -TLR9 258 -TLX1 15 -TLX1NB 12 -TLX2 6 -TLX3 0 -TM2D1 429 -TM2D2 1462 -TM2D3 1931 -TM4SF1 898 -TM4SF1-AS1 0 -TM4SF18 684 -TM4SF19 0 -TM4SF19-AS1 8 -TM4SF19-TCTEX1D2 5 -TM4SF20 6 -TM4SF4 7 -TM4SF5 0 -TM6SF1 259 -TM6SF2 117 -TM7SF2 673 -TM7SF3 1884 -TM9SF1 1523 -TM9SF2 3680 -TM9SF3 4560 -TM9SF4 2995 -TMA16 242 -TMA7 735 -TMBIM1 3910 -TMBIM4 1200 -TMBIM6 19006 -TMC1 58 -TMC2 105 -TMC3 2 -TMC3-AS1 8 -TMC4 0 -TMC5 29 -TMC6 1022 -TMC7 159 -TMC8 356 -TMCC1 2001 -TMCC1-AS1 112 -TMCC2 2955 -TMCC3 1433 -TMCO1 2232 -TMCO2 1 -TMCO3 1772 -TMCO4 388 -TMCO5A 0 -TMCO5B 0 -TMCO6 231 -TMED1 877 -TMED10 7503 -TMED10P1 79 -TMED11P 5 -TMED2 4367 -TMED3 1936 -TMED4 2674 -TMED5 3435 -TMED6 30 -TMED7 2045 -TMED7-TICAM2 3 -TMED8 134 -TMED9 2744 -TMEFF1 66 -TMEFF2 935 -TMEM100 217 -TMEM101 433 -TMEM102 33 -TMEM104 801 -TMEM105 0 -TMEM106A 146 -TMEM106B 1635 -TMEM106C 1394 -TMEM107 415 -TMEM108 767 -TMEM108-AS1 27 -TMEM109 2050 -TMEM11 840 -TMEM110 603 -TMEM110-MUSTN1 0 -TMEM114 90 -TMEM115 1508 -TMEM116 204 -TMEM117 201 -TMEM119 457 -TMEM120A 1232 -TMEM120B 1229 -TMEM121 223 -TMEM123 3665 -TMEM125 29 -TMEM126A 464 -TMEM126B 1219 -TMEM127 2335 -TMEM128 280 -TMEM129 1937 -TMEM130 11667 -TMEM131 2194 -TMEM132A 7980 -TMEM132B 1863 -TMEM132C 762 -TMEM132D 400 -TMEM132E 872 -TMEM133 212 -TMEM134 353 -TMEM135 586 -TMEM136 642 -TMEM138 492 -TMEM139 69 -TMEM140 674 -TMEM141 568 -TMEM143 263 -TMEM144 813 -TMEM145 989 -TMEM147 1610 -TMEM147-AS1 113 -TMEM14A 1049 -TMEM14B 435 -TMEM14C 1406 -TMEM14E 3 -TMEM150A 597 -TMEM150B 52 -TMEM150C 401 -TMEM151A 1257 -TMEM151B 3103 -TMEM154 124 -TMEM155 48 -TMEM156 67 -TMEM158 1776 -TMEM159 276 -TMEM160 697 -TMEM161A 591 -TMEM161B 336 -TMEM161B-AS1 291 -TMEM163 772 -TMEM164 1439 -TMEM165 1612 -TMEM167A 2455 -TMEM167B 1605 -TMEM168 584 -TMEM169 116 -TMEM17 501 -TMEM170A 2033 -TMEM170B 1112 -TMEM171 12 -TMEM173 608 -TMEM174 5 -TMEM175 1333 -TMEM176A 1799 -TMEM176B 2070 -TMEM177 123 -TMEM178A 925 -TMEM178B 1493 -TMEM179 0 -TMEM179B 668 -TMEM18 384 -TMEM180 607 -TMEM181 1811 -TMEM182 152 -TMEM183A 504 -TMEM183B 151 -TMEM184A 54 -TMEM184B 4385 -TMEM184C 1108 -TMEM185A 237 -TMEM185B 1062 -TMEM186 264 -TMEM187 217 -TMEM189 585 -TMEM189-UBE2V1 0 -TMEM19 1001 -TMEM190 18 -TMEM191A 48 -TMEM191B 14 -TMEM191C 1 -TMEM192 951 -TMEM196 350 -TMEM198 516 -TMEM198B 501 -TMEM199 632 -TMEM2 1401 -TMEM200A 148 -TMEM200B 93 -TMEM200C 508 -TMEM201 1138 -TMEM202 0 -TMEM203 785 -TMEM204 553 -TMEM205 2086 -TMEM206 534 -TMEM207 0 -TMEM208 605 -TMEM209 455 -TMEM210 0 -TMEM211 3 -TMEM212 0 -TMEM212-AS1 0 -TMEM213 12 -TMEM214 2565 -TMEM215 127 -TMEM216 554 -TMEM217 35 -TMEM218 365 -TMEM219 2632 -TMEM220 212 -TMEM220-AS1 12 -TMEM221 304 -TMEM222 1580 -TMEM223 236 -TMEM225 0 -TMEM229A 159 -TMEM229B 500 -TMEM230 2510 -TMEM231 560 -TMEM232 183 -TMEM233 28 -TMEM234 326 -TMEM235 342 -TMEM236 49 -TMEM237 859 -TMEM238 31 -TMEM239 0 -TMEM240 559 -TMEM241 247 -TMEM242 954 -TMEM243 1147 -TMEM244 1 -TMEM245 6265 -TMEM246 2211 -TMEM246-AS1 1 -TMEM247 0 -TMEM248 4197 -TMEM249 122 -TMEM25 1867 -TMEM251 0 -TMEM252 1 -TMEM253 47 -TMEM254 591 -TMEM254-AS1 240 -TMEM255A 1380 -TMEM255B 248 -TMEM256 357 -TMEM256-PLSCR3 5 -TMEM257 104 -TMEM258 841 -TMEM259 7024 -TMEM26 33 -TMEM26-AS1 1 -TMEM260 690 -TMEM261 725 -TMEM262 9 -TMEM263 1748 -TMEM265 481 -TMEM27 19 -TMEM30A 6236 -TMEM30B 181 -TMEM30C 0 -TMEM31 37 -TMEM33 1785 -TMEM35 2585 -TMEM37 31 -TMEM38A 292 -TMEM38B 435 -TMEM39A 779 -TMEM39B 482 -TMEM40 3 -TMEM41A 669 -TMEM41B 1090 -TMEM42 693 -TMEM43 3760 -TMEM44 400 -TMEM44-AS1 57 -TMEM45A 101 -TMEM45B 97 -TMEM47 5526 -TMEM5 406 -TMEM5-AS1 11 -TMEM50A 1887 -TMEM50B 429 -TMEM51 269 -TMEM51-AS1 38 -TMEM52 35 -TMEM52B 23 -TMEM53 232 -TMEM54 1688 -TMEM55A 976 -TMEM55B 1403 -TMEM56 693 -TMEM56-RWDD3 35 -TMEM57 1334 -TMEM59 6847 -TMEM59L 17148 -TMEM60 416 -TMEM61 14 -TMEM62 348 -TMEM63A 1540 -TMEM63B 2210 -TMEM63C 2996 -TMEM64 1115 -TMEM65 948 -TMEM67 639 -TMEM68 306 -TMEM69 378 -TMEM70 893 -TMEM71 86 -TMEM72 1 -TMEM72-AS1 26 -TMEM74 112 -TMEM74B 622 -TMEM75 1 -TMEM79 1013 -TMEM80 637 -TMEM81 418 -TMEM82 0 -TMEM86A 137 -TMEM86B 290 -TMEM87A 1375 -TMEM87B 687 -TMEM88 130 -TMEM88B 74 -TMEM89 0 -TMEM8A 1430 -TMEM8B 1565 -TMEM8C 0 -TMEM9 3315 -TMEM91 1087 -TMEM92 18 -TMEM92-AS1 4 -TMEM95 7 -TMEM97 402 -TMEM98 685 -TMEM99 179 -TMEM9B 1799 -TMEM9B-AS1 129 -TMF1 1875 -TMIE 1192 -TMIGD1 0 -TMIGD2 23 -TMIGD3 231 -TMLHE 199 -TMLHE-AS1 0 -TMOD1 1413 -TMOD2 6185 -TMOD3 1383 -TMOD4 32 -TMPO 1385 -TMPO-AS1 27 -TMPPE 100 -TMPRSS11A 2 -TMPRSS11B 1 -TMPRSS11BNL 0 -TMPRSS11D 1 -TMPRSS11E 0 -TMPRSS11F 4 -TMPRSS11GP 0 -TMPRSS12 3 -TMPRSS13 4 -TMPRSS15 1 -TMPRSS2 1 -TMPRSS3 33 -TMPRSS4 2 -TMPRSS4-AS1 0 -TMPRSS5 472 -TMPRSS6 32 -TMPRSS7 2 -TMPRSS9 72 -TMSB10 12403 -TMSB15A 17 -TMSB15B 0 -TMSB4X 4671 -TMSB4Y 3 -TMTC1 3261 -TMTC2 805 -TMTC3 784 -TMTC4 316 -TMUB1 1331 -TMUB2 1187 -TMX1 879 -TMX2 1500 -TMX2-CTNND1 0 -TMX3 1687 -TMX4 6243 -TNC 1691 -TNF 0 -TNFAIP1 1749 -TNFAIP2 1110 -TNFAIP3 778 -TNFAIP6 47 -TNFAIP8 244 -TNFAIP8L1 866 -TNFAIP8L2 62 -TNFAIP8L2-SCNM1 0 -TNFAIP8L3 207 -TNFRSF10A 104 -TNFRSF10B 901 -TNFRSF10C 21 -TNFRSF10D 973 -TNFRSF11A 35 -TNFRSF11B 298 -TNFRSF12A 1214 -TNFRSF13B 3 -TNFRSF13C 11 -TNFRSF14 0 -TNFRSF17 17 -TNFRSF18 33 -TNFRSF19 1800 -TNFRSF1A 6481 -TNFRSF1B 498 -TNFRSF21 1637 -TNFRSF25 831 -TNFRSF4 24 -TNFRSF6B 15 -TNFRSF8 6 -TNFRSF9 49 -TNFSF10 486 -TNFSF11 4 -TNFSF12 1337 -TNFSF12-TNFSF13 1 -TNFSF13 306 -TNFSF13B 239 -TNFSF14 502 -TNFSF15 4 -TNFSF18 1 -TNFSF4 136 -TNFSF8 45 -TNFSF9 68 -TNIK 3711 -TNIP1 2815 -TNIP2 1411 -TNIP3 11 -TNK1 94 -TNK2 9040 -TNKS 3466 -TNKS1BP1 4818 -TNKS2 2860 -TNKS2-AS1 20 -TNMD 3 -TNN 57 -TNNC1 17 -TNNC2 39 -TNNI1 4 -TNNI2 3 -TNNI3 38 -TNNI3K 0 -TNNT1 34 -TNNT2 33 -TNNT3 1 -TNP1 1 -TNP2 0 -TNPO1 3181 -TNPO2 6147 -TNPO3 2814 -TNR 1112 -TNRC18 7455 -TNRC18P1 5 -TNRC6A 7563 -TNRC6B 4762 -TNRC6C 3681 -TNRC6C-AS1 336 -TNS1 10753 -TNS2 6984 -TNS3 7042 -TNS4 6 -TNXA 0 -TNXB 16 -TOB1 1821 -TOB1-AS1 112 -TOB2 6653 -TOB2P1 47 -TOE1 256 -TOLLIP 4918 -TOLLIP-AS1 32 -TOM1 1839 -TOM1L1 438 -TOM1L2 5813 -TOMM20 4216 -TOMM20L 8 -TOMM22 960 -TOMM34 1763 -TOMM40 1360 -TOMM40L 344 -TOMM5 1097 -TOMM6 1923 -TOMM7 3503 -TOMM70A 2174 -TONSL 171 -TONSL-AS1 17 -TOP1 4174 -TOP1MT 486 -TOP1P1 144 -TOP1P2 0 -TOP2A 23 -TOP2B 3983 -TOP3A 741 -TOP3B 570 -TOPAZ1 0 -TOPBP1 665 -TOPORS 1466 -TOPORS-AS1 112 -TOR1A 920 -TOR1AIP1 2305 -TOR1AIP2 3349 -TOR1B 1038 -TOR2A 346 -TOR3A 632 -TOR4A 245 -TOX 605 -TOX2 1802 -TOX3 207 -TOX4 2370 -TP53 516 -TP53AIP1 40 -TP53BP1 4788 -TP53BP2 3406 -TP53I11 1852 -TP53I13 1064 -TP53I3 303 -TP53INP1 511 -TP53INP2 8989 -TP53RK 596 -TP53TG1 290 -TP53TG3 0 -TP53TG3B 0 -TP53TG3C 0 -TP53TG3D 5 -TP53TG5 20 -TP63 31 -TP73 139 -TP73-AS1 1209 -TPBG 800 -TPBGL 44 -TPCN1 2452 -TPCN2 571 -TPD52 3402 -TPD52L1 2721 -TPD52L2 4770 -TPD52L3 0 -TPGS1 577 -TPGS2 2625 -TPH1 12 -TPH2 3 -TPI1 3873 -TPI1P2 48 -TPI1P3 4 -TPK1 209 -TPM1 2913 -TPM2 4517 -TPM3 4490 -TPM3P9 266 -TPM4 3162 -TPMT 826 -TPO 3 -TPP1 10391 -TPP2 1128 -TPPP 11056 -TPPP2 2 -TPPP3 5217 -TPR 3195 -TPRA1 1101 -TPRG1 20 -TPRG1-AS1 5 -TPRG1-AS2 1 -TPRG1L 3893 -TPRKB 242 -TPRN 853 -TPRX1 94 -TPRXL 19 -TPSAB1 1 -TPSB2 14 -TPSD1 3 -TPSG1 3 -TPST1 1532 -TPST2 1309 -TPT1 43823 -TPT1-AS1 446 -TPTE 4 -TPTE2 7 -TPTE2P1 509 -TPTE2P3 16 -TPTE2P5 176 -TPTE2P6 10 -TPTEP1 322 -TPX2 32 -TRA2A 3687 -TRA2B 3610 -TRABD 1370 -TRABD2A 54 -TRABD2B 107 -TRADD 295 -TRAF1 1079 -TRAF2 1384 -TRAF3 2643 -TRAF3IP1 2263 -TRAF3IP2 927 -TRAF3IP2-AS1 1250 -TRAF3IP3 53 -TRAF4 706 -TRAF5 347 -TRAF6 1596 -TRAF7 2018 -TRAFD1 862 -TRAIP 29 -TRAK1 3828 -TRAK2 8582 -TRAM1 3142 -TRAM1L1 97 -TRAM2 1286 -TRAM2-AS1 241 -TRANK1 1353 -TRAP1 1828 -TRAPPC1 1906 -TRAPPC10 802 -TRAPPC11 1047 -TRAPPC12 386 -TRAPPC13 633 -TRAPPC2 883 -TRAPPC2B 113 -TRAPPC2L 458 -TRAPPC3 1857 -TRAPPC3L 3 -TRAPPC4 868 -TRAPPC5 1350 -TRAPPC6A 172 -TRAPPC6B 1255 -TRAPPC8 1264 -TRAPPC9 1234 -TRAT1 2 -TRDMT1 256 -TRDN 7605 -TREH 24 -TREM1 35 -TREM2 536 -TREML1 23 -TREML2 2 -TREML3P 0 -TREML4 1 -TREML5P 0 -TRERF1 843 -TRERNA1 4 -TREX1 220 -TREX2 5 -TRG-AS1 6 -TRH 386 -TRHDE 91 -TRHDE-AS1 173 -TRHR 4 -TRIAP1 243 -TRIB1 768 -TRIB2 1366 -TRIB3 936 -TRIL 2426 -TRIM10 0 -TRIM11 1154 -TRIM13 1300 -TRIM14 638 -TRIM15 0 -TRIM16 808 -TRIM16L 143 -TRIM17 511 -TRIM2 7072 -TRIM21 367 -TRIM22 1654 -TRIM23 903 -TRIM24 854 -TRIM25 2436 -TRIM26 192 -TRIM27 8 -TRIM28 5430 -TRIM29 29 -TRIM3 1004 -TRIM31 0 -TRIM31-AS1 0 -TRIM32 510 -TRIM33 2837 -TRIM34 16 -TRIM35 641 -TRIM36 640 -TRIM37 1958 -TRIM38 646 -TRIM39 0 -TRIM39-RPP21 0 -TRIM4 1280 -TRIM40 0 -TRIM41 3736 -TRIM42 0 -TRIM43 0 -TRIM43B 0 -TRIM44 9991 -TRIM45 191 -TRIM46 755 -TRIM47 1416 -TRIM48 0 -TRIM49 1 -TRIM49B 1 -TRIM49C 0 -TRIM49D1 0 -TRIM49D2 0 -TRIM5 756 -TRIM50 2 -TRIM51 0 -TRIM51HP 0 -TRIM52 651 -TRIM52-AS1 302 -TRIM53AP 0 -TRIM54 3 -TRIM55 7 -TRIM56 3329 -TRIM58 615 -TRIM59 71 -TRIM6 90 -TRIM6-TRIM34 0 -TRIM60 0 -TRIM61 40 -TRIM62 592 -TRIM63 2 -TRIM64 0 -TRIM64B 0 -TRIM64C 0 -TRIM65 1115 -TRIM66 962 -TRIM67 136 -TRIM68 555 -TRIM69 15 -TRIM7 167 -TRIM71 21 -TRIM72 7 -TRIM73 0 -TRIM74 0 -TRIM77 0 -TRIM8 6049 -TRIM9 3102 -TRIML1 0 -TRIML2 0 -TRIO 4280 -TRIOBP 1807 -TRIP10 2175 -TRIP11 1309 -TRIP12 5763 -TRIP13 60 -TRIP4 704 -TRIP6 1441 -TRIQK 1000 -TRIT1 491 -TRMT1 1466 -TRMT10A 276 -TRMT10B 704 -TRMT10C 409 -TRMT11 398 -TRMT112 2150 -TRMT12 457 -TRMT13 454 -TRMT1L 976 -TRMT2A 1098 -TRMT2B 433 -TRMT44 203 -TRMT5 495 -TRMT6 517 -TRMT61A 880 -TRMT61B 239 -TRMU 847 -TRNAU1AP 547 -TRNP1 996 -TRNT1 514 -TRO 3319 -TROAP 6 -TROVE2 1000 -TRPA1 9 -TRPC1 670 -TRPC2 10 -TRPC3 133 -TRPC4 187 -TRPC4AP 2908 -TRPC5 78 -TRPC5OS 14 -TRPC6 134 -TRPC7 74 -TRPM1 0 -TRPM2 789 -TRPM2-AS 12 -TRPM3 685 -TRPM4 615 -TRPM5 15 -TRPM6 116 -TRPM7 2316 -TRPM8 51 -TRPS1 2472 -TRPT1 458 -TRPV1 1098 -TRPV2 387 -TRPV3 392 -TRPV4 53 -TRPV5 0 -TRPV6 3 -TRRAP 3862 -TRUB1 518 -TRUB2 1015 -TRY2P 0 -TSACC 75 -TSC1 3415 -TSC2 3593 -TSC22D1 14699 -TSC22D1-AS1 164 -TSC22D2 1624 -TSC22D3 3642 -TSC22D4 6834 -TSEN15 719 -TSEN2 420 -TSEN34 0 -TSEN54 466 -TSFM 727 -TSG1 6 -TSG101 1615 -TSGA10 285 -TSGA10IP 28 -TSGA13 2 -TSHB 0 -TSHR 141 -TSHZ1 4457 -TSHZ2 3334 -TSHZ3 828 -TSIX 47 -TSKS 23 -TSKU 281 -TSL 0 -TSLP 52 -TSN 1963 -TSNARE1 729 -TSNAX 633 -TSNAX-DISC1 0 -TSNAXIP1 612 -TSPAN1 27 -TSPAN10 34 -TSPAN11 465 -TSPAN12 164 -TSPAN13 2923 -TSPAN14 2028 -TSPAN15 146 -TSPAN16 14 -TSPAN17 809 -TSPAN18 449 -TSPAN19 33 -TSPAN2 159 -TSPAN3 10222 -TSPAN31 890 -TSPAN32 19 -TSPAN33 1299 -TSPAN4 701 -TSPAN5 1099 -TSPAN6 1428 -TSPAN7 8881 -TSPAN8 20 -TSPAN9 937 -TSPEAR 79 -TSPEAR-AS1 67 -TSPEAR-AS2 20 -TSPO 960 -TSPO2 0 -TSPY1 0 -TSPY10 0 -TSPY2 0 -TSPY26P 170 -TSPY3 0 -TSPY4 0 -TSPY8 0 -TSPYL1 6454 -TSPYL2 19623 -TSPYL4 11711 -TSPYL5 1178 -TSPYL6 32 -TSR1 686 -TSR2 3088 -TSR3 1183 -TSSC1 859 -TSSC2 23 -TSSC4 1060 -TSSK1B 1 -TSSK2 0 -TSSK3 232 -TSSK4 104 -TSSK6 61 -TST 605 -TSTA3 0 -TSTD1 416 -TSTD2 412 -TSTD3 215 -TTBK1 2526 -TTBK2 1093 -TTC1 2479 -TTC12 339 -TTC13 627 -TTC14 2709 -TTC16 28 -TTC17 1846 -TTC19 1656 -TTC21A 553 -TTC21B 679 -TTC21B-AS1 0 -TTC22 79 -TTC23 671 -TTC23L 82 -TTC24 2 -TTC25 490 -TTC26 503 -TTC27 258 -TTC28 2319 -TTC28-AS1 468 -TTC29 98 -TTC3 14310 -TTC30A 142 -TTC30B 36 -TTC31 393 -TTC32 95 -TTC33 862 -TTC34 1 -TTC36 15 -TTC37 2253 -TTC38 833 -TTC39A 422 -TTC39A-AS1 2 -TTC39B 147 -TTC39C 403 -TTC39C-AS1 21 -TTC3P1 928 -TTC4 26 -TTC41P 78 -TTC5 485 -TTC6 99 -TTC7A 1485 -TTC7B 2002 -TTC8 891 -TTC9 1629 -TTC9B 1051 -TTC9C 563 -TTF1 1115 -TTF2 189 -TTI1 797 -TTI2 184 -TTK 6 -TTL 1153 -TTLL1 327 -TTLL10 54 -TTLL11 358 -TTLL12 1134 -TTLL13P 71 -TTLL2 15 -TTLL3 420 -TTLL4 762 -TTLL5 1134 -TTLL6 61 -TTLL7 2014 -TTLL9 210 -TTN 1139 -TTN-AS1 67 -TTPA 256 -TTPAL 1318 -TTR 4795 -TTTY1 0 -TTTY10 0 -TTTY11 0 -TTTY12 0 -TTTY13 0 -TTTY14 0 -TTTY15 0 -TTTY16 0 -TTTY17A 0 -TTTY17B 0 -TTTY17C 0 -TTTY18 0 -TTTY19 0 -TTTY1B 0 -TTTY2 0 -TTTY20 0 -TTTY21 0 -TTTY21B 0 -TTTY22 0 -TTTY23 0 -TTTY23B 0 -TTTY2B 0 -TTTY3 0 -TTTY3B 0 -TTTY4 0 -TTTY4B 0 -TTTY4C 0 -TTTY5 0 -TTTY6 0 -TTTY6B 0 -TTTY7 0 -TTTY7B 0 -TTTY8 0 -TTTY8B 0 -TTTY9A 0 -TTTY9B 0 -TTYH1 40 -TTYH2 1621 -TTYH3 3512 -TUB 3625 -TUB-AS1 7 -TUBA1A 13032 -TUBA1B 11450 -TUBA1C 887 -TUBA3C 4 -TUBA3D 78 -TUBA3E 44 -TUBA3FP 157 -TUBA4A 2213 -TUBA4B 59 -TUBA8 418 -TUBAL3 6 -TUBB 717 -TUBB1 239 -TUBB2A 3173 -TUBB2B 3965 -TUBB3 7690 -TUBB4A 12288 -TUBB4B 7668 -TUBB6 729 -TUBB8 2 -TUBBP5 32 -TUBD1 512 -TUBE1 993 -TUBG1 867 -TUBG2 1996 -TUBGCP2 1901 -TUBGCP3 286 -TUBGCP4 1561 -TUBGCP5 10 -TUBGCP6 3659 -TUFM 3672 -TUFT1 368 -TUG1 5923 -TULP1 10 -TULP2 48 -TULP3 1286 -TULP4 2363 -TUNAR 492 -TUSC1 600 -TUSC2 1674 -TUSC3 3141 -TUSC5 6 -TUSC7 14 -TUSC8 4 -TUT1 1134 -TVP23A 396 -TVP23B 293 -TVP23C 256 -TVP23C-CDRT4 1 -TWF1 848 -TWF2 965 -TWIST1 117 -TWIST2 295 -TWISTNB 873 -TWSG1 1078 -TXK 25 -TXLNA 4333 -TXLNB 245 -TXLNG 1962 -TXLNGY 6 -TXN 1289 -TXN2 1885 -TXNDC11 1196 -TXNDC12 1636 -TXNDC12-AS1 1 -TXNDC15 2441 -TXNDC16 373 -TXNDC17 380 -TXNDC2 2 -TXNDC5 63 -TXNDC8 0 -TXNDC9 320 -TXNIP 10980 -TXNL1 2040 -TXNL4A 2050 -TXNL4B 730 -TXNRD1 2623 -TXNRD2 498 -TXNRD3 86 -TXNRD3NB 2 -TYK2 3213 -TYMP 739 -TYMS 16 -TYMSOS 19 -TYR 0 -TYRO3 2011 -TYRO3P 0 -TYROBP 947 -TYRP1 9 -TYSND1 320 -TYW1 414 -TYW1B 239 -TYW3 1661 -TYW5 533 -U2AF1 5 -U2AF1L4 291 -U2AF2 8846 -U2SURP 3024 -UACA 1071 -UAP1 1008 -UAP1L1 870 -UBA1 10800 -UBA2 2063 -UBA3 1303 -UBA5 1232 -UBA52 6300 -UBA6 1385 -UBA6-AS1 336 -UBA7 711 -UBAC1 1403 -UBAC2 1221 -UBAC2-AS1 24 -UBALD1 1671 -UBALD2 2123 -UBAP1 3299 -UBAP1L 327 -UBAP2 1429 -UBAP2L 4349 -UBASH3A 4 -UBASH3B 200 -UBB 29187 -UBC 51787 -UBD 4 -UBE2A 1479 -UBE2B 2945 -UBE2C 22 -UBE2D1 530 -UBE2D2 3829 -UBE2D3 7591 -UBE2D4 754 -UBE2DNL 1 -UBE2E1 2230 -UBE2E1-AS1 2 -UBE2E2 1243 -UBE2E3 1035 -UBE2E4P 39 -UBE2F 1118 -UBE2F-SCLY 2 -UBE2G1 900 -UBE2G2 3478 -UBE2H 6745 -UBE2I 3136 -UBE2J1 2094 -UBE2J2 1785 -UBE2K 2393 -UBE2L3 3941 -UBE2L6 2228 -UBE2M 3125 -UBE2MP1 295 -UBE2N 2296 -UBE2NL 5 -UBE2O 2742 -UBE2Q1 3855 -UBE2Q1-AS1 3 -UBE2Q2 1303 -UBE2Q2L 0 -UBE2Q2P1 138 -UBE2Q2P2 31 -UBE2QL1 1920 -UBE2R2 3645 -UBE2S 649 -UBE2T 154 -UBE2U 0 -UBE2V1 84 -UBE2V2 1625 -UBE2W 1265 -UBE2Z 3181 -UBE3A 4022 -UBE3B 1468 -UBE3C 2034 -UBE3D 128 -UBE4A 2623 -UBE4B 2600 -UBFD1 2880 -UBIAD1 410 -UBL3 3834 -UBL4A 1036 -UBL4B 8 -UBL5 2377 -UBL7 1088 -UBL7-AS1 23 -UBLCP1 599 -UBN1 1660 -UBN2 2746 -UBOX5 328 -UBOX5-AS1 12 -UBP1 3318 -UBQLN1 4724 -UBQLN2 2972 -UBQLN3 0 -UBQLN4 1040 -UBQLNL 90 -UBR1 2201 -UBR2 3144 -UBR3 1963 -UBR4 9304 -UBR5 3741 -UBR5-AS1 22 -UBR7 67 -UBTD1 553 -UBTD2 690 -UBTF 3976 -UBTFL1 0 -UBXN1 2493 -UBXN10 636 -UBXN10-AS1 29 -UBXN11 1420 -UBXN2A 709 -UBXN2B 1426 -UBXN4 5941 -UBXN6 5266 -UBXN7 1680 -UBXN8 416 -UCA1 2 -UCHL1 19549 -UCHL1-AS1 2 -UCHL3 344 -UCHL5 833 -UCK1 1867 -UCK2 614 -UCKL1 1107 -UCKL1-AS1 306 -UCMA 0 -UCN 173 -UCN2 30 -UCN3 0 -UCP1 2 -UCP2 508 -UCP3 442 -UEVLD 323 -UFC1 3026 -UFD1L 891 -UFL1 1384 -UFM1 2542 -UFSP1 45 -UFSP2 1020 -UG0898H09 585 -UGCG 1839 -UGDH 947 -UGDH-AS1 156 -UGGT1 4223 -UGGT2 604 -UGP2 3303 -UGT1A1 0 -UGT1A10 0 -UGT1A3 0 -UGT1A4 0 -UGT1A5 0 -UGT1A6 0 -UGT1A7 0 -UGT1A8 0 -UGT1A9 0 -UGT2A1 2 -UGT2A2 0 -UGT2A3 0 -UGT2B10 0 -UGT2B11 0 -UGT2B15 0 -UGT2B17 0 -UGT2B28 0 -UGT2B4 0 -UGT2B7 0 -UGT3A1 0 -UGT3A2 31 -UGT8 593 -UHMK1 4533 -UHRF1 119 -UHRF1BP1 1119 -UHRF1BP1L 973 -UHRF2 1068 -UIMC1 972 -ULBP1 62 -ULBP2 13 -ULBP3 35 -ULK1 3695 -ULK2 1371 -ULK3 1686 -ULK4 123 -ULK4P1 0 -ULK4P2 0 -ULK4P3 0 -UMAD1 728 -UMOD 0 -UMODL1 30 -UMODL1-AS1 35 -UMPS 517 -UNC119 1631 -UNC119B 2953 -UNC13A 4205 -UNC13B 1922 -UNC13C 639 -UNC13D 803 -UNC45A 1511 -UNC45B 12 -UNC50 1085 -UNC5A 2058 -UNC5B 2539 -UNC5B-AS1 17 -UNC5C 1107 -UNC5CL 31 -UNC5D 825 -UNC79 0 -UNC80 2425 -UNC93A 0 -UNC93B1 287 -UNCX 47 -UNG 1284 -UNK 1784 -UNKL 1135 -UNQ6494 0 -UOX 58 -UPB1 6 -UPF1 5682 -UPF2 4231 -UPF3A 2388 -UPF3B 1790 -UPK1A 28 -UPK1A-AS1 2 -UPK1B 19 -UPK2 15 -UPK3A 23 -UPK3B 2 -UPK3BL 0 -UPP1 1236 -UPP2 61 -UPRT 502 -UQCC1 1474 -UQCC2 1258 -UQCC3 556 -UQCR10 1883 -UQCR11 3009 -UQCRB 5878 -UQCRBP1 42 -UQCRC1 2467 -UQCRC2 2581 -UQCRFS1 940 -UQCRH 1542 -UQCRHL 294 -UQCRQ 2048 -URAD 0 -URAHP 102 -URB1 1564 -URB1-AS1 198 -URB2 230 -URGCP 1992 -URGCP-MRPS24 4 -URI1 2421 -URM1 1096 -UROC1 6 -UROD 1390 -UROS 821 -USB1 1543 -USE1 646 -USF1 1442 -USF2 9581 -USH1C 298 -USH1G 5 -USH2A 42 -USHBP1 187 -USMG5 2004 -USO1 2607 -USP1 1217 -USP10 1444 -USP11 12804 -USP12 1461 -USP12-AS1 0 -USP12-AS2 29 -USP13 596 -USP14 2207 -USP15 1161 -USP16 1936 -USP17L1 1 -USP17L10 0 -USP17L11 0 -USP17L12 0 -USP17L13 0 -USP17L15 0 -USP17L17 0 -USP17L18 0 -USP17L19 0 -USP17L2 1 -USP17L20 0 -USP17L21 0 -USP17L22 0 -USP17L24 0 -USP17L25 0 -USP17L26 0 -USP17L27 0 -USP17L28 0 -USP17L29 0 -USP17L3 0 -USP17L30 0 -USP17L4 0 -USP17L5 0 -USP17L6P 0 -USP17L7 1 -USP17L8 0 -USP17L9P 0 -USP18 108 -USP19 2483 -USP2 682 -USP2-AS1 13 -USP20 2428 -USP21 1708 -USP22 13874 -USP24 3261 -USP25 1395 -USP26 0 -USP27X 1395 -USP27X-AS1 121 -USP28 630 -USP29 2 -USP3 655 -USP3-AS1 72 -USP30 1385 -USP30-AS1 12 -USP31 1820 -USP32 1925 -USP32P1 264 -USP32P2 164 -USP33 2299 -USP34 6482 -USP35 1076 -USP36 1770 -USP37 800 -USP38 941 -USP39 1233 -USP4 2032 -USP40 1704 -USP42 1605 -USP43 470 -USP44 187 -USP45 768 -USP46 3849 -USP46-AS1 35 -USP47 6183 -USP48 1870 -USP49 929 -USP5 3429 -USP50 0 -USP51 555 -USP53 1633 -USP54 4062 -USP6 69 -USP6NL 851 -USP7 3616 -USP8 3171 -USP9X 5442 -USP9Y 1 -USPL1 1827 -UST 4419 -UTAT33 2 -UTF1 15 -UTP11L 635 -UTP14A 391 -UTP14C 1372 -UTP15 337 -UTP18 572 -UTP20 595 -UTP23 457 -UTP3 725 -UTP6 730 -UTRN 4106 -UTS2 47 -UTS2B 2 -UTS2R 7 -UTY 1 -UVRAG 1107 -UVSSA 711 -UXS1 1556 -UXT 755 -UXT-AS1 12 -VAC14 1349 -VAC14-AS1 325 -VAMP1 1876 -VAMP2 19056 -VAMP3 2707 -VAMP4 1071 -VAMP5 681 -VAMP7 68 -VAMP8 246 -VANGL1 271 -VANGL2 1429 -VAPA 4933 -VAPB 3692 -VARS 0 -VARS2 66 -VASH1 3070 -VASH2 79 -VASN 0 -VASP 1322 -VAT1 12295 -VAT1L 12882 -VAV1 441 -VAV2 1254 -VAV3 257 -VAV3-AS1 0 -VAX1 144 -VAX2 77 -VBP1 1556 -VCAM1 471 -VCAN 3467 -VCL 2779 -VCP 6066 -VCPIP1 872 -VCPKMT 245 -VCX 0 -VCX2 0 -VCX3A 1 -VCX3B 0 -VCY 0 -VCY1B 0 -VDAC1 3486 -VDAC2 1282 -VDAC3 2702 -VDR 70 -VEGFA 6205 -VEGFB 4369 -VEGFC 100 -VENTX 55 -VENTXP1 0 -VENTXP7 3 -VEPH1 38 -VEZF1 1826 -VEZT 1349 -VGF 54087 -VGLL1 1 -VGLL2 18 -VGLL3 605 -VGLL4 2014 -VHL 4003 -VHLL 91 -VIL1 3 -VILL 526 -VIM 46788 -VIM-AS1 27 -VIMP 1311 -VIP 201 -VIPAS39 733 -VIPR1 160 -VIPR1-AS1 0 -VIPR2 627 -VIT 26 -VKORC1 1248 -VKORC1L1 1333 -VLDLR 291 -VLDLR-AS1 3 -VMA21 2056 -VMAC 348 -VMO1 66 -VMP1 1151 -VN1R1 289 -VN1R10P 2 -VN1R2 4 -VN1R4 0 -VN1R5 0 -VNN1 13 -VNN2 30 -VNN3 6 -VOPP1 708 -VPRBP 942 -VPREB1 0 -VPREB3 28 -VPS11 1896 -VPS13A 990 -VPS13A-AS1 1 -VPS13B 1548 -VPS13C 3718 -VPS13D 4467 -VPS16 881 -VPS18 995 -VPS25 426 -VPS26A 1446 -VPS26B 3346 -VPS28 2455 -VPS29 1313 -VPS33A 569 -VPS33B 347 -VPS35 4987 -VPS36 1110 -VPS37A 739 -VPS37B 2003 -VPS37C 1194 -VPS37D 424 -VPS39 3139 -VPS41 2505 -VPS45 1999 -VPS4A 4004 -VPS4B 945 -VPS50 823 -VPS51 2587 -VPS52 0 -VPS53 4208 -VPS54 1038 -VPS72 1442 -VPS8 2289 -VPS9D1 1596 -VPS9D1-AS1 238 -VRK1 197 -VRK2 159 -VRK3 835 -VRTN 1 -VSIG1 38 -VSIG10 630 -VSIG10L 224 -VSIG2 62 -VSIG4 706 -VSIG8 96 -VSNL1 2603 -VSTM1 4 -VSTM2A 894 -VSTM2A-OT1 77 -VSTM2B 464 -VSTM2L 3175 -VSTM4 1280 -VSTM5 8 -VSX1 141 -VSX2 46 -VTA1 1040 -VTCN1 1 -VTI1A 453 -VTI1B 1522 -VTN 74 -VTRNA1-1 1 -VTRNA1-2 0 -VTRNA1-3 1 -VTRNA2-1 1 -VWA1 2582 -VWA2 136 -VWA3A 905 -VWA3B 185 -VWA5A 2455 -VWA5B1 301 -VWA5B2 1477 -VWA7 0 -VWA8 884 -VWA8-AS1 8 -VWA9 708 -VWC2 316 -VWC2L 28 -VWC2L-IT1 0 -VWCE 211 -VWDE 19 -VWF 5567 -WAC 8638 -WAC-AS1 762 -WAPL 1601 -WARS 8611 -WARS2 182 -WARS2-IT1 1 -WAS 590 -WASF1 1463 -WASF2 5482 -WASF3 7111 -WASH1 151 -WASH2P 89 -WASH3P 141 -WASH5P 4 -WASH7P 113 -WASIR2 69 -WASL 3098 -WBP1 53 -WBP11 1944 -WBP11P1 2 -WBP1L 2036 -WBP2 10632 -WBP2NL 37 -WBP4 2036 -WBP5 4881 -WBSCR16 1167 -WBSCR17 1465 -WBSCR22 1293 -WBSCR27 20 -WBSCR28 0 -WDFY1 1383 -WDFY2 659 -WDFY3 4941 -WDFY3-AS2 399 -WDFY4 347 -WDHD1 64 -WDPCP 217 -WDR1 6617 -WDR11 1527 -WDR11-AS1 39 -WDR12 386 -WDR13 3499 -WDR17 741 -WDR18 653 -WDR19 1731 -WDR20 1017 -WDR24 774 -WDR25 373 -WDR26 4748 -WDR27 333 -WDR3 549 -WDR31 112 -WDR33 3036 -WDR34 1302 -WDR35 928 -WDR36 615 -WDR37 993 -WDR38 155 -WDR4 238 -WDR41 654 -WDR43 700 -WDR44 688 -WDR45 1503 -WDR45B 3516 -WDR46 7 -WDR47 1898 -WDR48 1977 -WDR49 253 -WDR5 1476 -WDR53 279 -WDR54 382 -WDR55 585 -WDR59 2184 -WDR5B 413 -WDR6 9489 -WDR60 2738 -WDR61 711 -WDR62 75 -WDR63 207 -WDR64 2 -WDR66 996 -WDR7 2221 -WDR70 439 -WDR72 65 -WDR73 1016 -WDR74 784 -WDR75 831 -WDR76 191 -WDR77 696 -WDR78 565 -WDR81 90 -WDR82 4905 -WDR83 586 -WDR83OS 1491 -WDR86 365 -WDR86-AS1 76 -WDR87 9 -WDR88 21 -WDR89 409 -WDR90 858 -WDR91 739 -WDR92 469 -WDR93 156 -WDSUB1 461 -WDTC1 4351 -WDYHV1 412 -WEE1 462 -WEE2 0 -WEE2-AS1 2 -WFDC1 220 -WFDC10A 0 -WFDC10B 1 -WFDC11 0 -WFDC12 0 -WFDC13 3 -WFDC2 111 -WFDC21P 23 -WFDC3 3 -WFDC5 0 -WFDC6 1 -WFDC8 1 -WFDC9 0 -WFIKKN1 139 -WFIKKN2 185 -WFS1 5773 -WHAMM 842 -WHAMMP1 68 -WHAMMP2 24 -WHAMMP3 139 -WHSC1 3322 -WHSC1L1 2514 -WI2-2373I1.2 1 -WIBG 479 -WIF1 12218 -WIPF1 1487 -WIPF2 5166 -WIPF3 1530 -WIPI1 433 -WIPI2 3459 -WISP1 21 -WISP2 22 -WISP3 6 -WIZ 2327 -WLS 5230 -WNK1 13777 -WNK2 4227 -WNK3 660 -WNK4 530 -WNT1 6 -WNT10A 29 -WNT10B 152 -WNT11 180 -WNT16 31 -WNT2 19 -WNT2B 340 -WNT3 0 -WNT3A 1 -WNT4 323 -WNT5A 508 -WNT5B 356 -WNT6 78 -WNT7A 50 -WNT7B 358 -WNT8A 7 -WNT8B 12 -WNT9A 13 -WNT9B 0 -WRAP53 226 -WRAP73 624 -WRB 2116 -WRN 399 -WRNIP1 2610 -WSB1 3438 -WSB2 4580 -WSCD1 1519 -WSCD2 512 -WSPAR 0 -WT1 5 -WT1-AS 1 -WTAP 2456 -WTAPP1 7 -WTH3DI 210 -WTIP 802 -WWC1 2539 -WWC2 1228 -WWC2-AS1 0 -WWC2-AS2 11 -WWC3 1896 -WWOX 830 -WWP1 1790 -WWP2 2335 -WWTR1 4679 -WWTR1-AS1 12 -XAB2 1596 -XACT 1 -XAF1 2344 -XAGE1B 0 -XAGE1E 0 -XAGE2 0 -XAGE3 0 -XAGE5 0 -XBP1 5578 -XCL1 15 -XCL2 0 -XCR1 0 -XDH 8 -XG 2 -XGY2 0 -XIAP 4176 -XIRP1 26 -XIRP2 1 -XIRP2-AS1 0 -XIST 8795 -XK 503 -XKR3 1 -XKR4 167 -XKR5 4 -XKR6 163 -XKR7 39 -XKR8 293 -XKR9 12 -XKRX 70 -XKRY 0 -XKRY2 0 -XLOC_007697 1 -XLOC_008559 0 -XLOC_009911 0 -XPA 496 -XPC 1743 -XPNPEP1 939 -XPNPEP2 8 -XPNPEP3 1464 -XPO1 9824 -XPO4 779 -XPO5 969 -XPO6 3281 -XPO7 3364 -XPOT 2755 -XPR1 2574 -XRCC1 879 -XRCC2 26 -XRCC3 548 -XRCC4 121 -XRCC5 4886 -XRCC6 3622 -XRCC6BP1 23 -XRCC6P5 1 -XRN1 1510 -XRN2 1762 -XRRA1 686 -XXYLT1 347 -XXYLT1-AS1 0 -XXYLT1-AS2 10 -XYLB 86 -XYLT1 911 -XYLT2 754 -YAE1D1 240 -YAF2 1626 -YAP1 4106 -YARS 5014 -YARS2 407 -YBEY 255 -YBX1 5430 -YBX2 21 -YBX3 4603 -YBX3P1 169 -YDJC 336 -YEATS2 2061 -YEATS4 211 -YES1 1508 -YIF1A 800 -YIF1B 1070 -YIPF1 1212 -YIPF2 1358 -YIPF3 3112 -YIPF4 1035 -YIPF5 1247 -YIPF6 2314 -YIPF7 19 -YJEFN3 869 -YKT6 3551 -YLPM1 3458 -YME1L1 3722 -YOD1 474 -YPEL1 928 -YPEL2 1592 -YPEL3 4925 -YPEL4 675 -YPEL5 3454 -YRDC 478 -YTHDC1 1 -YTHDC2 1461 -YTHDF1 2127 -YTHDF2 1210 -YTHDF3 1756 -YTHDF3-AS1 27 -YWHAB 12976 -YWHAE 2030 -YWHAEP1 9 -YWHAEP7 2 -YWHAG 16390 -YWHAH 10902 -YWHAQ 7516 -YWHAZ 6533 -YY1 3017 -YY1AP1 2204 -YY1P2 0 -YY2 71 -ZACN 1 -ZADH2 1993 -ZAK 3996 -ZAN 1 -ZAP70 107 -ZAR1 18 -ZAR1L 0 -ZASP 0 -ZBBX 366 -ZBED1 1 -ZBED2 6 -ZBED3 159 -ZBED3-AS1 57 -ZBED4 955 -ZBED5 1282 -ZBED5-AS1 222 -ZBED6 1110 -ZBED6CL 238 -ZBED8 423 -ZBED9 11 -ZBP1 12 -ZBTB1 1799 -ZBTB10 1185 -ZBTB11 1413 -ZBTB11-AS1 90 -ZBTB12 0 -ZBTB14 488 -ZBTB16 2420 -ZBTB17 1302 -ZBTB18 2287 -ZBTB2 778 -ZBTB20 19097 -ZBTB20-AS1 29 -ZBTB20-AS3 2 -ZBTB20-AS4 11 -ZBTB21 1379 -ZBTB22 0 -ZBTB24 301 -ZBTB25 474 -ZBTB26 137 -ZBTB3 238 -ZBTB32 11 -ZBTB33 1709 -ZBTB34 726 -ZBTB37 106 -ZBTB38 2898 -ZBTB39 297 -ZBTB4 9058 -ZBTB40 2767 -ZBTB41 1047 -ZBTB42 143 -ZBTB43 1284 -ZBTB44 2260 -ZBTB45 558 -ZBTB46 1185 -ZBTB46-AS1 18 -ZBTB47 5734 -ZBTB48 665 -ZBTB49 185 -ZBTB5 812 -ZBTB6 410 -ZBTB7A 6864 -ZBTB7B 1680 -ZBTB7C 694 -ZBTB8A 605 -ZBTB8B 341 -ZBTB8OS 366 -ZBTB9 6 -ZC2HC1A 668 -ZC2HC1B 1 -ZC2HC1C 479 -ZC3H10 248 -ZC3H11A 4101 -ZC3H12A 815 -ZC3H12B 432 -ZC3H12C 1090 -ZC3H12D 99 -ZC3H13 11184 -ZC3H14 2213 -ZC3H15 3103 -ZC3H18 3100 -ZC3H3 715 -ZC3H4 2580 -ZC3H6 2163 -ZC3H7A 1365 -ZC3H7B 6679 -ZC3H8 307 -ZC3HAV1 6675 -ZC3HAV1L 75 -ZC3HC1 479 -ZC4H2 462 -ZCCHC10 492 -ZCCHC11 2394 -ZCCHC12 13930 -ZCCHC13 0 -ZCCHC14 2301 -ZCCHC16 4 -ZCCHC17 2571 -ZCCHC18 522 -ZCCHC2 1678 -ZCCHC24 5924 -ZCCHC3 2285 -ZCCHC4 201 -ZCCHC5 0 -ZCCHC6 666 -ZCCHC7 788 -ZCCHC8 1372 -ZCCHC9 634 -ZCRB1 4114 -ZCWPW1 389 -ZCWPW2 47 -ZDBF2 1747 -ZDHHC1 441 -ZDHHC11 315 -ZDHHC12 150 -ZDHHC13 341 -ZDHHC14 1487 -ZDHHC15 440 -ZDHHC16 645 -ZDHHC17 2220 -ZDHHC18 2604 -ZDHHC19 36 -ZDHHC2 1660 -ZDHHC20 2925 -ZDHHC21 1378 -ZDHHC22 2060 -ZDHHC23 284 -ZDHHC24 360 -ZDHHC3 1539 -ZDHHC4 870 -ZDHHC5 2154 -ZDHHC6 764 -ZDHHC7 1727 -ZDHHC8 2649 -ZDHHC8P1 16 -ZDHHC9 4006 -ZEB1 5994 -ZEB1-AS1 132 -ZEB2 3191 -ZEB2-AS1 6 -ZER1 6632 -ZFAND1 1043 -ZFAND2A 2122 -ZFAND2B 819 -ZFAND3 4470 -ZFAND4 462 -ZFAND5 6739 -ZFAND6 1231 -ZFAS1 1365 -ZFAT 325 -ZFAT-AS1 1 -ZFC3H1 1919 -ZFHX2 2197 -ZFHX3 4949 -ZFHX4 1954 -ZFHX4-AS1 48 -ZFP1 649 -ZFP14 865 -ZFP2 195 -ZFP28 810 -ZFP3 577 -ZFP30 633 -ZFP36 6570 -ZFP36L1 13416 -ZFP36L2 2983 -ZFP37 203 -ZFP41 1345 -ZFP42 0 -ZFP57 0 -ZFP62 924 -ZFP64 462 -ZFP69 161 -ZFP69B 137 -ZFP82 320 -ZFP90 2269 -ZFP91 2600 -ZFP91-CNTF 1 -ZFP92 78 -ZFPL1 538 -ZFPM1 655 -ZFPM2 484 -ZFPM2-AS1 4 -ZFR 5069 -ZFR2 1291 -ZFX 1779 -ZFX-AS1 5 -ZFY 0 -ZFYVE1 1095 -ZFYVE16 1720 -ZFYVE19 891 -ZFYVE21 2097 -ZFYVE26 1198 -ZFYVE27 2027 -ZFYVE28 841 -ZFYVE9 2383 -ZG16 0 -ZG16B 0 -ZGLP1 665 -ZGPAT 937 -ZGRF1 111 -ZHX1 5339 -ZHX1-C8orf76 34 -ZHX2 1296 -ZHX3 5798 -ZIC1 1796 -ZIC2 1246 -ZIC3 201 -ZIC4 425 -ZIC5 349 -ZIK1 121 -ZIM2 17 -ZIM2-AS1 58 -ZIM3 0 -ZKSCAN1 3814 -ZKSCAN2 428 -ZKSCAN3 187 -ZKSCAN4 285 -ZKSCAN5 875 -ZKSCAN7 148 -ZKSCAN8 1733 -ZMAT1 2398 -ZMAT2 2343 -ZMAT3 2586 -ZMAT4 63 -ZMAT5 190 -ZMIZ1 5665 -ZMIZ1-AS1 19 -ZMIZ2 3787 -ZMPSTE24 2007 -ZMYM1 329 -ZMYM2 2749 -ZMYM3 3006 -ZMYM4 2496 -ZMYM5 564 -ZMYM6 807 -ZMYM6NB 277 -ZMYND10 996 -ZMYND11 5142 -ZMYND12 205 -ZMYND15 84 -ZMYND19 619 -ZMYND8 5332 -ZNF10 683 -ZNF100 1 -ZNF101 268 -ZNF106 10543 -ZNF107 309 -ZNF112 470 -ZNF114 255 -ZNF117 1700 -ZNF12 1130 -ZNF121 229 -ZNF124 293 -ZNF131 881 -ZNF132 298 -ZNF133 901 -ZNF134 381 -ZNF135 507 -ZNF136 142 -ZNF137P 377 -ZNF138 368 -ZNF14 384 -ZNF140 650 -ZNF141 133 -ZNF142 1361 -ZNF143 826 -ZNF146 1937 -ZNF148 2101 -ZNF154 1519 -ZNF155 151 -ZNF157 18 -ZNF16 240 -ZNF160 1056 -ZNF165 100 -ZNF169 66 -ZNF17 327 -ZNF174 447 -ZNF175 555 -ZNF177 0 -ZNF18 276 -ZNF180 194 -ZNF181 442 -ZNF182 477 -ZNF184 373 -ZNF185 357 -ZNF189 1262 -ZNF19 188 -ZNF192P1 89 -ZNF195 880 -ZNF197 818 -ZNF197-AS1 2 -ZNF2 206 -ZNF20 6 -ZNF200 321 -ZNF202 684 -ZNF204P 1237 -ZNF205 963 -ZNF205-AS1 60 -ZNF207 3231 -ZNF208 1032 -ZNF211 822 -ZNF212 399 -ZNF213 1095 -ZNF213-AS1 136 -ZNF214 118 -ZNF215 53 -ZNF217 931 -ZNF219 3686 -ZNF22 953 -ZNF221 326 -ZNF222 221 -ZNF223 182 -ZNF224 87 -ZNF225 184 -ZNF226 531 -ZNF227 1060 -ZNF229 352 -ZNF23 1044 -ZNF230 165 -ZNF232 226 -ZNF233 198 -ZNF234 676 -ZNF235 239 -ZNF236 1030 -ZNF239 252 -ZNF24 4519 -ZNF248 1924 -ZNF25 1542 -ZNF250 805 -ZNF251 0 -ZNF252P 1211 -ZNF252P-AS1 39 -ZNF253 402 -ZNF254 590 -ZNF256 174 -ZNF257 58 -ZNF26 349 -ZNF260 827 -ZNF263 1263 -ZNF264 2185 -ZNF266 670 -ZNF267 463 -ZNF268 606 -ZNF271P 2587 -ZNF273 819 -ZNF274 806 -ZNF275 2491 -ZNF276 1218 -ZNF277 493 -ZNF28 402 -ZNF280A 0 -ZNF280B 9 -ZNF280C 142 -ZNF280D 1220 -ZNF281 1227 -ZNF282 1008 -ZNF283 210 -ZNF284 202 -ZNF285 287 -ZNF286A 348 -ZNF286B 195 -ZNF287 165 -ZNF292 2953 -ZNF295-AS1 17 -ZNF296 183 -ZNF3 895 -ZNF30 261 -ZNF30-AS1 2 -ZNF300 200 -ZNF300P1 197 -ZNF302 1776 -ZNF304 527 -ZNF311 1 -ZNF316 3343 -ZNF317 1139 -ZNF318 1741 -ZNF319 971 -ZNF32 1020 -ZNF32-AS1 22 -ZNF32-AS2 82 -ZNF32-AS3 0 -ZNF320 871 -ZNF321P 0 -ZNF322 127 -ZNF324 626 -ZNF324B 156 -ZNF326 1919 -ZNF329 797 -ZNF330 916 -ZNF331 2973 -ZNF333 706 -ZNF334 715 -ZNF335 1210 -ZNF337 1900 -ZNF337-AS1 61 -ZNF33A 1266 -ZNF33B 888 -ZNF33BP1 4 -ZNF34 468 -ZNF341 377 -ZNF341-AS1 18 -ZNF343 661 -ZNF345 177 -ZNF346 1010 -ZNF347 496 -ZNF35 444 -ZNF350 443 -ZNF350-AS1 155 -ZNF354A 544 -ZNF354B 207 -ZNF354C 105 -ZNF358 5682 -ZNF362 1494 -ZNF365 645 -ZNF366 647 -ZNF367 67 -ZNF37A 2803 -ZNF37BP 1911 -ZNF382 228 -ZNF383 260 -ZNF384 1820 -ZNF385A 3991 -ZNF385B 97 -ZNF385C 73 -ZNF385D 125 -ZNF385D-AS1 0 -ZNF385D-AS2 0 -ZNF391 103 -ZNF394 756 -ZNF395 2513 -ZNF396 88 -ZNF397 1149 -ZNF398 893 -ZNF404 333 -ZNF407 537 -ZNF408 414 -ZNF41 421 -ZNF410 1383 -ZNF414 695 -ZNF415 719 -ZNF416 240 -ZNF417 661 -ZNF418 307 -ZNF419 513 -ZNF420 366 -ZNF423 1031 -ZNF425 276 -ZNF426 290 -ZNF428 1981 -ZNF429 771 -ZNF43 100 -ZNF430 402 -ZNF431 313 -ZNF432 474 -ZNF433 129 -ZNF436 1247 -ZNF436-AS1 500 -ZNF438 616 -ZNF439 313 -ZNF44 364 -ZNF440 240 -ZNF441 239 -ZNF442 33 -ZNF443 114 -ZNF444 2631 -ZNF445 1699 -ZNF446 534 -ZNF449 177 -ZNF45 472 -ZNF451 1545 -ZNF454 171 -ZNF460 382 -ZNF461 414 -ZNF462 1381 -ZNF467 475 -ZNF468 231 -ZNF469 459 -ZNF470 645 -ZNF471 939 -ZNF473 1442 -ZNF474 33 -ZNF479 0 -ZNF48 567 -ZNF480 691 -ZNF483 638 -ZNF484 376 -ZNF485 63 -ZNF486 178 -ZNF487 184 -ZNF488 144 -ZNF490 759 -ZNF491 31 -ZNF492 7 -ZNF493 965 -ZNF496 424 -ZNF497 236 -ZNF500 427 -ZNF501 87 -ZNF502 342 -ZNF503 1969 -ZNF503-AS1 6 -ZNF503-AS2 177 -ZNF506 910 -ZNF507 1138 -ZNF510 958 -ZNF511 525 -ZNF512 2008 -ZNF512B 1777 -ZNF513 1074 -ZNF514 522 -ZNF516 2404 -ZNF517 398 -ZNF518A 1226 -ZNF518B 998 -ZNF519 105 -ZNF521 1482 -ZNF524 386 -ZNF525 247 -ZNF526 401 -ZNF527 321 -ZNF528 1141 -ZNF528-AS1 249 -ZNF529 1231 -ZNF529-AS1 172 -ZNF530 40 -ZNF532 2312 -ZNF534 19 -ZNF536 305 -ZNF540 865 -ZNF541 38 -ZNF542P 1214 -ZNF543 236 -ZNF544 959 -ZNF546 557 -ZNF547 429 -ZNF548 623 -ZNF549 433 -ZNF550 650 -ZNF551 428 -ZNF552 113 -ZNF554 281 -ZNF555 381 -ZNF556 6 -ZNF557 424 -ZNF558 1004 -ZNF559 446 -ZNF559-ZNF177 11 -ZNF560 15 -ZNF561 747 -ZNF561-AS1 190 -ZNF562 1256 -ZNF563 122 -ZNF564 361 -ZNF565 357 -ZNF566 683 -ZNF567 350 -ZNF568 656 -ZNF569 580 -ZNF57 84 -ZNF570 233 -ZNF571 144 -ZNF571-AS1 195 -ZNF572 50 -ZNF573 208 -ZNF574 805 -ZNF575 133 -ZNF576 393 -ZNF577 708 -ZNF578 127 -ZNF579 1282 -ZNF580 2256 -ZNF581 457 -ZNF582 160 -ZNF582-AS1 453 -ZNF583 302 -ZNF584 451 -ZNF585A 742 -ZNF585B 1169 -ZNF586 245 -ZNF587 2061 -ZNF587B 205 -ZNF589 616 -ZNF592 2652 -ZNF593 334 -ZNF594 612 -ZNF595 388 -ZNF596 196 -ZNF597 162 -ZNF598 1327 -ZNF599 178 -ZNF600 115 -ZNF605 1628 -ZNF606 631 -ZNF607 457 -ZNF608 1217 -ZNF609 3905 -ZNF610 343 -ZNF611 504 -ZNF613 285 -ZNF614 676 -ZNF615 596 -ZNF616 230 -ZNF618 1596 -ZNF619 173 -ZNF620 177 -ZNF621 3078 -ZNF622 803 -ZNF623 11 -ZNF624 106 -ZNF625 61 -ZNF625-ZNF20 5 -ZNF626 769 -ZNF627 297 -ZNF628 266 -ZNF629 1003 -ZNF630 252 -ZNF630-AS1 1 -ZNF638 5493 -ZNF639 857 -ZNF641 922 -ZNF644 1356 -ZNF645 2 -ZNF646 1173 -ZNF648 29 -ZNF649 235 -ZNF649-AS1 0 -ZNF652 2097 -ZNF653 673 -ZNF654 656 -ZNF655 2649 -ZNF658 58 -ZNF658B 24 -ZNF660 103 -ZNF662 351 -ZNF663P 134 -ZNF664 7367 -ZNF664-FAM101A 2 -ZNF665 90 -ZNF667 930 -ZNF667-AS1 1005 -ZNF668 487 -ZNF669 159 -ZNF670 95 -ZNF670-ZNF695 0 -ZNF671 694 -ZNF672 981 -ZNF674 214 -ZNF674-AS1 146 -ZNF675 231 -ZNF676 14 -ZNF677 95 -ZNF678 304 -ZNF679 0 -ZNF680 535 -ZNF681 188 -ZNF682 97 -ZNF683 9 -ZNF684 77 -ZNF687 1403 -ZNF688 655 -ZNF689 354 -ZNF69 195 -ZNF691 300 -ZNF692 1885 -ZNF695 5 -ZNF696 499 -ZNF697 164 -ZNF699 65 -ZNF7 620 -ZNF70 348 -ZNF700 327 -ZNF701 416 -ZNF702P 169 -ZNF703 1772 -ZNF704 2376 -ZNF705A 1 -ZNF705B 0 -ZNF705D 0 -ZNF705E 1 -ZNF705G 0 -ZNF706 859 -ZNF707 18 -ZNF708 763 -ZNF709 513 -ZNF71 368 -ZNF710 980 -ZNF711 621 -ZNF713 598 -ZNF714 677 -ZNF716 0 -ZNF717 229 -ZNF718 479 -ZNF720 315 -ZNF721 1472 -ZNF724P 10 -ZNF726 7 -ZNF727 44 -ZNF728 89 -ZNF729 3 -ZNF730 36 -ZNF732 54 -ZNF733P 0 -ZNF735 1 -ZNF736 592 -ZNF737 321 -ZNF738 270 -ZNF74 732 -ZNF740 1317 -ZNF746 1231 -ZNF747 550 -ZNF749 245 -ZNF750 29 -ZNF75A 623 -ZNF75D 427 -ZNF76 1388 -ZNF761 906 -ZNF763 56 -ZNF764 434 -ZNF765 254 -ZNF766 583 -ZNF767P 940 -ZNF768 2810 -ZNF77 60 -ZNF770 1971 -ZNF771 799 -ZNF772 550 -ZNF773 307 -ZNF774 174 -ZNF775 423 -ZNF776 941 -ZNF777 1166 -ZNF778 187 -ZNF780A 570 -ZNF780B 1644 -ZNF781 282 -ZNF782 172 -ZNF783 732 -ZNF784 149 -ZNF785 881 -ZNF786 439 -ZNF787 1767 -ZNF788 209 -ZNF789 211 -ZNF79 271 -ZNF790 353 -ZNF790-AS1 113 -ZNF791 824 -ZNF792 75 -ZNF793 1040 -ZNF793-AS1 57 -ZNF799 107 -ZNF8 426 -ZNF80 2 -ZNF800 419 -ZNF804A 403 -ZNF804B 26 -ZNF805 660 -ZNF806 3 -ZNF808 478 -ZNF81 446 -ZNF812 31 -ZNF813 136 -ZNF814 1468 -ZNF815P 253 -ZNF816 115 -ZNF816-ZNF321P 2 -ZNF818P 317 -ZNF821 737 -ZNF823 100 -ZNF826P 9 -ZNF827 2021 -ZNF829 344 -ZNF83 3888 -ZNF830 500 -ZNF831 148 -ZNF833P 13 -ZNF835 248 -ZNF836 249 -ZNF837 127 -ZNF839 895 -ZNF84 1804 -ZNF841 1014 -ZNF843 43 -ZNF844 320 -ZNF845 215 -ZNF846 387 -ZNF847P 0 -ZNF85 2 -ZNF850 122 -ZNF852 210 -ZNF853 2045 -ZNF860 59 -ZNF862 1781 -ZNF865 1685 -ZNF876P 60 -ZNF878 26 -ZNF879 239 -ZNF880 559 -ZNF883 226 -ZNF888 84 -ZNF890P 120 -ZNF891 150 -ZNF90 45 -ZNF91 2665 -ZNF92 328 -ZNF93 58 -ZNF98 6 -ZNF99 20 -ZNFX1 2434 -ZNHIT1 1810 -ZNHIT2 373 -ZNHIT3 106 -ZNHIT6 1802 -ZNRD1 15 -ZNRD1-AS1 8 -ZNRF1 1787 -ZNRF2 749 -ZNRF2P1 140 -ZNRF2P2 4 -ZNRF3 1427 -ZNRF3-AS1 15 -ZNRF4 3 -ZP1 15 -ZP2 2 -ZP3 104 -ZP4 0 -ZPBP 1 -ZPBP2 0 -ZPLD1 3 -ZPR1 733 -ZRANB1 3209 -ZRANB2 3289 -ZRANB2-AS1 15 -ZRANB2-AS2 11 -ZRANB3 185 -ZRSR2 1153 -ZSCAN1 141 -ZSCAN10 2 -ZSCAN12 391 -ZSCAN12P1 152 -ZSCAN16 104 -ZSCAN16-AS1 410 -ZSCAN18 7180 -ZSCAN2 315 -ZSCAN20 221 -ZSCAN21 188 -ZSCAN22 487 -ZSCAN23 76 -ZSCAN25 444 -ZSCAN26 1093 -ZSCAN29 1015 -ZSCAN30 1175 -ZSCAN31 388 -ZSCAN32 655 -ZSCAN4 9 -ZSCAN5A 63 -ZSCAN5B 8 -ZSCAN9 470 -ZSWIM1 689 -ZSWIM2 12 -ZSWIM3 234 -ZSWIM4 777 -ZSWIM5 461 -ZSWIM6 1913 -ZSWIM7 912 -ZSWIM8 6474 -ZSWIM8-AS1 100 -ZUFSP 339 -ZW10 286 -ZWILCH 85 -ZWINT 27 -ZXDA 229 -ZXDB 533 -ZXDC 1642 -ZYG11A 33 -ZYG11B 3345 -ZYX 3180 -ZZEF1 2517 -ZZZ3 1483 -__no_feature 26814752 -__ambiguous 594277 -__too_low_aQual 0 -__not_aligned 0 -__alignment_not_unique 0 From a07132b40d1c154423a43e0fa11dcb72bdff686d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:26:34 +0100 Subject: [PATCH 16/52] Update .gitignore file to ignore additional file types --- .gitignore | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 3163136..ea296a7 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,13 @@ target *.gtf perf.data htseq -*.sam \ No newline at end of file +*.sam +IGV* +*.dot +*.rust +*.python +test* +perf* +*.bai +*.txt +*.svg \ No newline at end of file From 51425f091fea54eb1caa71264144c7df0f74c017 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:26:52 +0100 Subject: [PATCH 17/52] Refactor Feature struct and add default implementation --- src/feature.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/feature.rs b/src/feature.rs index 067523f..28446e8 100644 --- a/src/feature.rs +++ b/src/feature.rs @@ -6,7 +6,16 @@ pub struct Feature { pub chr: String, pub start: u32, pub end: u32, - pub start_sorted_index: usize, - pub end_sorted_index: usize, +} +// default implementation for Feature +impl Default for Feature { + fn default() -> Self { + Feature { + name: String::from(""), + chr: String::from(""), + start: 0, + end: 0 + } + } } \ No newline at end of file From b243e59a1125655d43d4fc46656a467276121d9d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:27:05 +0100 Subject: [PATCH 18/52] Add max_end_left and max_end_right fields to Node struct --- src/node.rs | 58 ++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 44 insertions(+), 14 deletions(-) diff --git a/src/node.rs b/src/node.rs index a94a6d6..eb77989 100644 --- a/src/node.rs +++ b/src/node.rs @@ -7,6 +7,8 @@ use std::io::Write; #[derive(Debug, Eq, PartialEq, Clone)] pub struct Node { pub x_center: i32, + pub max_end_left: i32, + pub max_end_right: i32, pub s_center: HashSet, left_node: Option>, right_node: Option>, @@ -18,6 +20,8 @@ impl Node { pub fn new(x_center: i32, s_center: HashSet) -> Self { Node { x_center, + max_end_left: 0, + max_end_right: 0, s_center, left_node: None, right_node: None, @@ -29,6 +33,8 @@ impl Node { pub fn new_empty() -> Self { Node { x_center: 0, + max_end_left: 0, + max_end_right: 0, s_center: HashSet::new(), left_node: None, right_node: None, @@ -219,14 +225,19 @@ impl Node { let mut result = HashSet::new(); for interval in &self.s_center { if interval.contains_point(point) { + // print in red + //eprintln!("\x1b[31mFound interval: {:?}\x1b[0m", interval); result.insert(interval); } } - if point < self.x_center { + if point < self.max_end_left { if let Some(left_node) = &self.left_node { + //eprintln!("\x1b[32mx_center: {}, Going to the left, Data: {:?}", self.x_center, self.s_center); result.extend(left_node.search_point(point)); } - } else if point > self.x_center { + } + if point > self.x_center { + //eprintln!("\x1b[33mx_center: {}, Going to the right, Data: {:?}", self.x_center, self.s_center); if let Some(right_node) = &self.right_node { result.extend(right_node.search_point(point)); } @@ -309,27 +320,46 @@ impl Node { } pub fn write_structure(&self, f: &mut File, indent: usize) -> std::fmt::Result { + // write as dot file connected by edges let newline = "\n"; let spaces = " ".repeat(indent); - - let _ = write!(f, "{}{}", self, newline); - if self.s_center.len() > 0 { - for interval in &self.s_center { - let _ = write!(f, "{} {}{}", spaces, interval, newline); - } - } + let current_data = self.s_center.iter().next().unwrap().data.as_ref().unwrap(); + let result = format!("{}{} [label=\"{}\n{}-{}\nmel: {}, mer: {}\"]{}", spaces, self.x_center,current_data.name, current_data.start, current_data.end, self.max_end_left, self.max_end_right, newline); + _ = write!(f, "{}", result); if let Some(left_node) = &self.left_node { - let _ = write!(f, "{}{}{}", spaces, "Left:", newline); - left_node.write_structure(f, indent+1)?; + _ = write!(f, "{}{} -> {}{}", spaces, self.x_center, left_node.x_center, newline); + left_node.write_structure(f, indent)?; } if let Some(right_node) = &self.right_node { - let _ = write!(f, "{}{}{}", spaces, "Right:", newline); - right_node.write_structure(f, indent+1)?; + _ = write!(f, "{}{} -> {}{}", spaces, self.x_center, right_node.x_center, newline); + right_node.write_structure(f, indent)?; } Ok(()) } -} + + pub fn update_max_ends(&mut self) { + if let Some(left_node) = &mut self.left_node { + left_node.update_max_ends(); + let max_end_left_node = std::cmp::max(left_node.max_end_left, left_node.max_end_right); + self.max_end_left = self.s_center.iter().map(|interval| interval.end).max().unwrap_or(0).max(max_end_left_node); + } + else { + self.max_end_left = self.s_center.iter().map(|interval| interval.end).max().unwrap_or(0); + } + if let Some(right_node) = &mut self.right_node { + right_node.update_max_ends(); + let max_end_right_node = std::cmp::max(right_node.max_end_left, right_node.max_end_right); + self.max_end_right = self.s_center.iter().map(|interval| interval.end).max().unwrap_or(0).max(max_end_right_node); + } + else { + self.max_end_right = self.s_center.iter().map(|interval| interval.end).max().unwrap_or(0); + } + } + + +} + // display format impl std::fmt::Display for Node { From 8d09056f773d773066bd6b951925b7cb88bca8ff Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:27:15 +0100 Subject: [PATCH 19/52] Fix off-by-one error in contains_point() method --- src/interval.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/interval.rs b/src/interval.rs index 1bbcbfa..f94f22a 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -30,7 +30,7 @@ impl Interval { } pub fn contains_point(&self, point: i32) -> bool { - self.start <= point && point < self.end + self.start <= point && point < self.end-1 } pub fn range_matches(&self, other: &Interval) -> bool { From e7fc91971b90a79deab4ba20d6efa9fd2e3f8c9e Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:27:32 +0100 Subject: [PATCH 20/52] Fix null interval check and update max ends --- src/intervaltree.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index ee17ec5..93bf135 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -28,7 +28,7 @@ impl IntervalTree { // check if intervals are not null for interval in &unique_intervals { if interval.is_null() { - panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree"); + panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree: {:?}", interval); } } let mut it = IntervalTree { @@ -41,6 +41,9 @@ impl IntervalTree { for interval in &unique_intervals { it.add_boundaries(interval); } + + it.top_node.as_mut().unwrap().update_max_ends(); + //eprintln!("added boundaries"); return it; } From 50b3b896d64a98c741596a869e62e7040754215a Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 13:29:02 +0100 Subject: [PATCH 21/52] Fully implement the intervaltree searching and add samfile output. --- src/main.rs | 222 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 178 insertions(+), 44 deletions(-) diff --git a/src/main.rs b/src/main.rs index a27d0b5..5b1fd85 100755 --- a/src/main.rs +++ b/src/main.rs @@ -1,12 +1,13 @@ use bam::record::cigar::Operation; use bam::record::tags::TagValue; -use bam::BamReader; +use bam::{BamReader, RecordWriter, SamWriter}; use feature::Feature; use intervaltree::IntervalTree; use interval::Interval; -use std::collections::HashMap; +use std::cmp::{max, min}; +use std::collections::{HashMap, HashSet}; use std::fs::File; -use std::io::{BufRead, BufReader, Write}; +use std::io::{BufRead, BufReader, BufWriter, Write}; use structopt::StructOpt; mod feature; @@ -32,32 +33,60 @@ fn main() { let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); let header = bam.header().clone(); let reference_names: Vec = header.reference_names().to_owned(); + let mut output_sam: Option>> = None; + if args.output_sam.is_some() { + output_sam = Some(SamWriter::from_path(args.output_sam.clone().unwrap(), header).expect("Could not create output sam file")); + } // bam fields: https://docs.rs/bam/0.3.0/bam/record/struct.Record.html // Read the gtf file let gtf = read_gtf(&args.gtf, args.t.as_str()); - // for overlap in gtf["1"].overlap(169680637, 169680637+25) { - // eprintln!("overlap: {:?}", overlap); + // let read= 21940455; + // eprintln!("Searching for reads overlapping position {}-{}...", read, read+25); + // for overlap in gtf["1"].overlap(read, read+25) { + // eprintln!("overlap: {:?}", overlap); // } - - if args.export_feature_map.is_some() { - let mut file = File::create(args.export_feature_map.clone().unwrap()).expect("Unable to create file"); + + + if args.export_feature_tree.is_some() { + eprintln!("Exporting feature trees as dot files..."); + let mut file = File::create(args.export_feature_tree.clone().unwrap()).expect("Unable to create file"); for (chr, tree) in gtf.iter() { - file.write_all(format!("{}:\n", chr).as_bytes()).expect("Unable to write data"); + // top node for each tree is the chromosome + file.write_all(format!("digraph {} {{\n", chr).as_bytes()).expect("Unable to write data"); let _ = tree.top_node.clone().unwrap().write_structure(&mut file, 0); + file.write_all("}\n".as_bytes()).expect("Unable to write data"); } } - + // exit(1) to prevent the rest of the program from running for debugging purposes - // std::process::exit(1); + //std::process::exit(1); let mut counts = prepare_count_hashmap(>f); - + let mut read_to_feature: HashMap, String> = HashMap::new(); let mut counter = 0; - count_reads(bam, &mut counter, &mut counts, &args, reference_names, gtf); + count_reads(bam, &mut counter, &mut counts, &args, reference_names, gtf, &mut read_to_feature); + + if args.output_sam.is_some() { + eprintln!("Writing output sam file..."); + // loop through the bam file again and write the reads to the output sam file + let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); + for record in bam { + let record = record.unwrap(); + let name = record.name(); + let feature = read_to_feature.get(name).unwrap(); + let mut record = record.clone(); + record.tags_mut().push_string(b"XF", feature.as_bytes()); + output_sam.as_mut().unwrap().write(&record).unwrap(); + } + + let mut output_sam = output_sam.unwrap(); + output_sam.flush().unwrap(); + output_sam.finish().unwrap(); + } if args.counts_output.is_some() { write_counts(counts, args, counter); } else { @@ -80,7 +109,7 @@ struct Args { // Mode // TODO: implement other modes - #[structopt(short = "m", long = "mode", default_value = "intersection-strict", possible_values = &["intersection-strict", "intersection-nonempty", "union"], help = "Mode to use for counting reads overlapping features. Possible values: intersection-strict, intersection-nonempty, union (default: intersection-strict).")] + #[structopt(short = "m", long = "mode", default_value = "union", possible_values = &["intersection-strict", "intersection-nonempty", "union"], help = "Mode to use for counting reads overlapping features. Possible values: intersection-strict, intersection-nonempty, union (default: intersection-strict).")] _m: String, // Stranded @@ -165,7 +194,14 @@ struct Args { long = "export_feature_map", help = "Filename to output the feature map for debugging purposes." )] - export_feature_map: Option, + export_feature_tree: Option, + + #[structopt( + short = "o", + long = "output_sam", + help = "Create a SAM file with the reads and their features." + )] + output_sam: Option, } fn prepare_count_hashmap(gtf: &HashMap) -> HashMap { @@ -225,13 +261,11 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap, args: &Args, + read_to_feature: &mut HashMap, String>, ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { + read_to_feature.insert(record.name().to_owned(), "__not_aligned".to_string()); *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; return true; } // Skip all reads that are secondary alignments if args.secondary_alignments == "ignore" && record.flag().all_bits(0x100) { + read_to_feature.insert(record.name().to_owned(), "".to_string()); return true; } // Skip all reads that are supplementary alignments if args.supplementary_alignments == "ignore" && record.flag().all_bits(0x800) { + read_to_feature.insert(record.name().to_owned(), "".to_string()); return true; } // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { + read_to_feature.insert(record.name().to_owned(), "__too_low_aQual".to_string()); *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; return true; } // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { + read_to_feature.insert(record.name().to_owned(), "__alignment_not_unique".to_string()); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -349,7 +389,15 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf: HashMap) { +fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf: HashMap, read_to_feature: &mut HashMap, String>) { + + let processing_function = match args._m.as_str() { + "intersection-strict" => process_intersection_strict_read, + "intersection-nonempty" => process_intersection_nonempty_read, + "union" => process_union_read, + _ => panic!("Invalid mode"), + }; + for record in bam { //eprintln!("{} records processed.", counter); *counter += 1; @@ -362,7 +410,7 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap 1"); - feature_name= String::default(); // construct partial reads for each cigar element with AlnMatch // keep track of feature_names for each partial read, if they are all the same, we can count the feature let mut start_pos = start_pos; @@ -423,51 +470,138 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap String { - let mut feature_name = String::default(); +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { + let mut feature = Feature::default(); - let overlapping_features = features.overlap(start_pos-1, end_pos); + let overlapping_features = features.overlap(start_pos, end_pos); if overlapping_features.len() == 0 { - return feature_name; + return feature; } else if overlapping_features.len() == 1 { - feature_name = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().name.clone(); + feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); } else { - *ambiguous = true; + check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, &record, counts, read_to_feature); } //todo!("process_partial_read"); - feature_name + feature +} + +fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) { + let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); + match feature_names.len() { + 0 => {}, + 1 => *feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(), + _ => *ambiguous = { + //use feature_names as the ambiguous feature + let mut feature_names: Vec = feature_names.into_iter().collect(); + feature_names.sort(); + // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) + read_to_feature.insert(record.name().to_owned(), format!("__ambiguous[{}]", feature_names.join("+"))); + for feature_name in feature_names { + *counts.entry(feature_name).or_insert(0) += 1; + } + + + true + } + + } +} + + +fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, output_sam: &mut Option>>, record: &bam::Record) { + let mut contained_by = Vec::new(); + for overlap in overlapping_features { + if overlap.start <= start_pos && overlap.end >= end_pos { + contained_by.push(overlap.data.as_ref().unwrap().clone()); + } + } + + let feature_names: HashSet = contained_by.iter().map(|f| f.name.clone()).collect(); + + match feature_names.len() { + 0 => *ambiguous = { + // get overlapping_features names + let mut names = HashSet::new(); + for overlap in overlapping_features { + names.insert(overlap.data.as_ref().unwrap().name.clone()); + } + if names.len() == 1 { + *feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); + false + } else { + // sort alphabetically + let mut names: Vec = names.into_iter().collect(); + names.sort(); + + // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) + if let Some(output_sam) = output_sam { + let mut record = record.clone(); + record.tags_mut().push_string(b"XF", format!("__ambiguous[{}]", names.join("+")).as_bytes()); + output_sam.write(&record).unwrap(); + } + true + } + }, + 1 => *feature = contained_by[0].clone(), + _ => *ambiguous = { + //use feature_names as the ambiguous feature + let mut feature_names: Vec = feature_names.into_iter().collect(); + feature_names.sort(); + // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) + if let Some(output_sam) = output_sam { + let mut record = record.clone(); + record.tags_mut().push_string(b"XF", format!("__ambiguous[{}]", feature_names.join("+")).as_bytes()); + output_sam.write(&record).unwrap(); + } + true + } + } +} + +fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { + todo!("process_partial_read for intersection-nonempty"); +} + +fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { + todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From 41fc83532f241c77239fe6ddcd76f297d1bc41f8 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 19:00:59 +0100 Subject: [PATCH 22/52] Update Feature struct fields to use integer types --- src/feature.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/feature.rs b/src/feature.rs index 28446e8..a704572 100644 --- a/src/feature.rs +++ b/src/feature.rs @@ -3,9 +3,9 @@ pub struct Feature { //type_: String, pub name: String, - pub chr: String, - pub start: u32, - pub end: u32, + pub chr: i32, + pub start: i32, + pub end: i32, } // default implementation for Feature @@ -13,7 +13,7 @@ impl Default for Feature { fn default() -> Self { Feature { name: String::from(""), - chr: String::from(""), + chr: 0, start: 0, end: 0 } From 808d9e664969f6eb5c3bb19e628af96076b55330 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 19:02:10 +0100 Subject: [PATCH 23/52] change trees from hashmap to a vector. Saves hashing chromosomes during loops --- src/main.rs | 114 +++++++++++++++++++++++++++++----------------------- 1 file changed, 64 insertions(+), 50 deletions(-) diff --git a/src/main.rs b/src/main.rs index 5b1fd85..357cd87 100755 --- a/src/main.rs +++ b/src/main.rs @@ -33,6 +33,7 @@ fn main() { let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); let header = bam.header().clone(); let reference_names: Vec = header.reference_names().to_owned(); + let ref_names_to_id: HashMap = reference_names.iter().enumerate().map(|(i, s)| (s.clone(), i as i32)).collect(); let mut output_sam: Option>> = None; if args.output_sam.is_some() { output_sam = Some(SamWriter::from_path(args.output_sam.clone().unwrap(), header).expect("Could not create output sam file")); @@ -40,7 +41,7 @@ fn main() { // bam fields: https://docs.rs/bam/0.3.0/bam/record/struct.Record.html // Read the gtf file - let gtf = read_gtf(&args.gtf, args.t.as_str()); + let gtf = read_gtf(&args.gtf, args.t.as_str(), &ref_names_to_id); // let read= 21940455; // eprintln!("Searching for reads overlapping position {}-{}...", read, read+25); @@ -52,10 +53,10 @@ fn main() { if args.export_feature_tree.is_some() { eprintln!("Exporting feature trees as dot files..."); let mut file = File::create(args.export_feature_tree.clone().unwrap()).expect("Unable to create file"); - for (chr, tree) in gtf.iter() { + for (chr, tree) in gtf.iter().enumerate() { // top node for each tree is the chromosome - file.write_all(format!("digraph {} {{\n", chr).as_bytes()).expect("Unable to write data"); - let _ = tree.top_node.clone().unwrap().write_structure(&mut file, 0); + file.write_all(format!("digraph {} {{\n", reference_names[chr]).as_bytes()).expect("Unable to write data"); + let _ = tree.as_ref().unwrap().top_node.clone().unwrap().write_structure(&mut file, 0); file.write_all("}\n".as_bytes()).expect("Unable to write data"); } } @@ -67,7 +68,7 @@ fn main() { let mut read_to_feature: HashMap, String> = HashMap::new(); let mut counter = 0; - count_reads(bam, &mut counter, &mut counts, &args, reference_names, gtf, &mut read_to_feature); + count_reads(bam, &mut counter, &mut counts, &args, gtf, &mut read_to_feature); if args.output_sam.is_some() { eprintln!("Writing output sam file..."); @@ -204,11 +205,14 @@ struct Args { output_sam: Option, } -fn prepare_count_hashmap(gtf: &HashMap) -> HashMap { +fn prepare_count_hashmap(gtf: &Vec>) -> HashMap { let mut counts = HashMap::with_capacity(gtf.len()); // add all features to the map - for features in gtf.values() { - for feature in features.all_intervals.iter() { + for tree in gtf { + if tree.is_none() { + continue; + } + for feature in tree.as_ref().unwrap().all_intervals.iter() { counts.entry(feature.data.as_ref().unwrap().name.clone()).or_insert(0); } } @@ -222,51 +226,54 @@ fn prepare_count_hashmap(gtf: &HashMap) -> HashMap HashMap { - let mut map: HashMap> = HashMap::new(); +fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMap) -> Vec> { + let mut map: HashMap> = HashMap::new(); let file = File::open(file_path).expect("Kan het bestand niet openen"); - let reader = BufReader::new(file); + let mut reader = BufReader::new(file); let mut counter = 0; - for line in reader.lines() { + let mut line = String::new(); + while reader.read_line(&mut line).unwrap() > 0 { counter += 1; if counter % 100000 == 0 { eprintln!("{} GFF lines processed.", counter); } - if let Ok(line) = line { - if line.starts_with('#') { - continue; - } - let fields: Vec<&str> = line.split('\t').collect(); - let feature_name = fields[2]; - if feature_name != feature_type_filter { - continue; - } - let attributes = fields[8]; + + if line.starts_with('#') { + line.clear(); + continue; + } + let fields: Vec<&str> = line.split('\t').collect(); + let feature_name = fields[2]; + if feature_name != feature_type_filter { + line.clear(); + continue; + } + let attributes = fields[8]; - let attributes: Vec<&str> = attributes.split(';').collect(); + let attributes: Vec<&str> = attributes.split(';').collect(); - let name = attributes - .iter() - .find(|&attr| attr.contains("gene_name")) - .unwrap_or(&"") - .trim(); + let name = attributes + .iter() + .find(|&attr| attr.contains("gene_name")) + .unwrap_or(&"") + .trim(); - let name = name.replace("gene_name ", ""); - let name = name.trim_matches('"'); + let name = name.replace("gene_name ", ""); + let name = name.trim_matches('"'); - let start = fields[3].parse::().unwrap_or(0); - let end = fields[4].parse::().unwrap_or(0); - let chr = fields[0].to_string(); + let start = fields[3].parse::().unwrap(); + let end = fields[4].parse::().unwrap()+1; + let chr_id = ref_names_to_id.get(fields[0]).unwrap(); - let feature = Feature { - name: name.to_string(), - chr: chr.clone(), - start: min(start, end), - end: max(start, end)+1, - }; + let feature = Feature { + name: name.to_string(), + chr: chr_id.clone(), + start: min(start, end), + end: max(start, end), + }; - map.entry(chr).or_default().push(Interval::new((start) as i32, (end+1) as i32, Some(feature))); - } + map.entry(*chr_id).or_default().push(Interval::new(start, end, Some(feature))); + line.clear(); } //let node = Node::from_intervals(intervals); // print the center node (withouth the children) @@ -278,16 +285,22 @@ fn read_gtf(file_path: &str, feature_type_filter: &str) -> HashMap = HashMap::new(); + // prepopulate the map with empty trees + let mut result: Vec> = Vec::with_capacity(ref_names_to_id.len()); + //eprintln!("{:?} chromosomes found.", ref_names_to_id.keys()); + for _ in 0..ref_names_to_id.len() { + result.push(None); + } for (chr, intervals) in map { let tree = IntervalTree::new(Some(intervals)); - result.insert(chr, tree); + result[chr as usize] = Some(tree); } eprintln!("done."); - - result + + //eprintln!("The amount of not empty trees: {}", result.iter().filter(|x| x.is_some()).count()); + result } fn should_skip_record( @@ -389,7 +402,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, reference_names: Vec, gtf: HashMap, read_to_feature: &mut HashMap, String>) { +fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut HashMap, String>) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -416,13 +429,12 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { From 126fc2debb76ed7cde6f04d2feb9135f31a779e3 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 19:22:01 +0100 Subject: [PATCH 24/52] Refactor read_gtf function to improve code readability and performance --- src/main.rs | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/src/main.rs b/src/main.rs index 357cd87..ef9d4e9 100755 --- a/src/main.rs +++ b/src/main.rs @@ -242,28 +242,30 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa line.clear(); continue; } - let fields: Vec<&str> = line.split('\t').collect(); - let feature_name = fields[2]; + let mut fields = line.split('\t'); + let chr_id = ref_names_to_id.get(fields.next().unwrap()).unwrap(); + //eprintln!("chr_id: {}", chr_id); + let feature_name = fields.nth(1).unwrap(); + //eprintln!("feature_name: {}", feature_name); + + + let start = fields.next().unwrap().parse::().unwrap(); + let end = fields.next().unwrap().parse::().unwrap()+1; + if feature_name != feature_type_filter { line.clear(); continue; } - let attributes = fields[8]; + let attributes = fields.nth(3).unwrap(); + //eprintln!("attributes: {}", attributes); - let attributes: Vec<&str> = attributes.split(';').collect(); - - let name = attributes - .iter() + let name = attributes.split(';') .find(|&attr| attr.contains("gene_name")) - .unwrap_or(&"") - .trim(); - - let name = name.replace("gene_name ", ""); - let name = name.trim_matches('"'); - - let start = fields[3].parse::().unwrap(); - let end = fields[4].parse::().unwrap()+1; - let chr_id = ref_names_to_id.get(fields[0]).unwrap(); + .unwrap_or("") + .trim() + .strip_prefix("gene_name ") + .unwrap_or("") + .trim_matches('"'); let feature = Feature { name: name.to_string(), From ab9b6956942c4f55e9d9e77332e8572b46b83085 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 22:02:00 +0100 Subject: [PATCH 25/52] use a vector to store return types, and use an enum to reduce memory usage --- src/main.rs | 65 +++++++++++++++++++++++++++++++++++------------------ 1 file changed, 43 insertions(+), 22 deletions(-) diff --git a/src/main.rs b/src/main.rs index ef9d4e9..2569444 100755 --- a/src/main.rs +++ b/src/main.rs @@ -65,7 +65,7 @@ fn main() { //std::process::exit(1); let mut counts = prepare_count_hashmap(>f); - let mut read_to_feature: HashMap, String> = HashMap::new(); + let mut read_to_feature: Vec = Vec::new(); let mut counter = 0; count_reads(bam, &mut counter, &mut counts, &args, gtf, &mut read_to_feature); @@ -74,12 +74,10 @@ fn main() { eprintln!("Writing output sam file..."); // loop through the bam file again and write the reads to the output sam file let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); - for record in bam { - let record = record.unwrap(); - let name = record.name(); - let feature = read_to_feature.get(name).unwrap(); - let mut record = record.clone(); - record.tags_mut().push_string(b"XF", feature.as_bytes()); + for (i,record) in bam.enumerate() { + let mut record = record.unwrap(); + let feature = read_to_feature[i].as_bytes(); + record.tags_mut().push_string(b"XF", &feature); output_sam.as_mut().unwrap().write(&record).unwrap(); } @@ -95,6 +93,29 @@ fn main() { } } +enum FeatureType { + Name(String), + __no_feature, + __ambiguous(String), + __not_aligned, + __too_low_aQual, + __alignment_not_unique, + none, +} + +impl FeatureType { + fn as_bytes(&self) -> Vec { + match self { + FeatureType::Name(s) => s.as_bytes().to_vec(), + FeatureType::__no_feature => b"__no_feature".to_vec(), + FeatureType::__ambiguous(s) => format!("__ambiguous[{}]", s).as_bytes().to_vec(), + FeatureType::__not_aligned => b"__not_aligned".to_vec(), + FeatureType::__too_low_aQual => b"__too_low_aQual".to_vec(), + FeatureType::__alignment_not_unique => b"__alignment_not_unique".to_vec(), + FeatureType::none => b"".to_vec(), + } + } +} // Use the structopt crate to parse command line arguments #[derive(StructOpt)] @@ -309,34 +330,34 @@ fn should_skip_record( record: &bam::Record, counts: &mut HashMap, args: &Args, - read_to_feature: &mut HashMap, String>, + read_to_feature: &mut Vec, ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { - read_to_feature.insert(record.name().to_owned(), "__not_aligned".to_string()); + read_to_feature.push(FeatureType::__not_aligned); *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; return true; } // Skip all reads that are secondary alignments if args.secondary_alignments == "ignore" && record.flag().all_bits(0x100) { - read_to_feature.insert(record.name().to_owned(), "".to_string()); + read_to_feature.push(FeatureType::__not_aligned); return true; } // Skip all reads that are supplementary alignments if args.supplementary_alignments == "ignore" && record.flag().all_bits(0x800) { - read_to_feature.insert(record.name().to_owned(), "".to_string()); + read_to_feature.push(FeatureType::none); return true; } // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { - read_to_feature.insert(record.name().to_owned(), "__too_low_aQual".to_string()); + read_to_feature.push(FeatureType::__too_low_aQual); *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; return true; } // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { - read_to_feature.insert(record.name().to_owned(), "__alignment_not_unique".to_string()); + read_to_feature.push(FeatureType::__alignment_not_unique); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -404,7 +425,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut HashMap, String>) { +fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut Vec) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -507,23 +528,23 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { let mut feature = Feature::default(); let overlapping_features = features.overlap(start_pos, end_pos); @@ -541,7 +562,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb feature } -fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) { +fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) { let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); match feature_names.len() { 0 => {}, @@ -551,7 +572,7 @@ fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: let mut feature_names: Vec = feature_names.into_iter().collect(); feature_names.sort(); // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - read_to_feature.insert(record.name().to_owned(), format!("__ambiguous[{}]", feature_names.join("+"))); + read_to_feature.push(FeatureType::__ambiguous(feature_names.join("+"))); for feature_name in feature_names { *counts.entry(feature_name).or_insert(0) += 1; } @@ -614,10 +635,10 @@ fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, e } } -fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { +fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut HashMap, String>) -> Feature { +fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From b22fdf77e47308265c7a702295a2dbd9bca632bc Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 5 Feb 2024 23:19:47 +0100 Subject: [PATCH 26/52] Add sam reading option + refactor enums to be more rustacean --- src/main.rs | 122 +++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 88 insertions(+), 34 deletions(-) diff --git a/src/main.rs b/src/main.rs index 2569444..dc600bb 100755 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,6 @@ use bam::record::cigar::Operation; use bam::record::tags::TagValue; -use bam::{BamReader, RecordWriter, SamWriter}; +use bam::{BamReader, RecordWriter, SamReader, SamWriter}; use feature::Feature; use intervaltree::IntervalTree; use interval::Interval; @@ -30,8 +30,11 @@ fn main() { } // Try to open the bam file, if it fails, print an error message - let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); - let header = bam.header().clone(); + let reads_reader = ReadsReader::from_path(args.bam.clone(), args.n); + let header = reads_reader.header().clone(); + // check if the header is valid + check_header_validity(&header, &args); + let reference_names: Vec = header.reference_names().to_owned(); let ref_names_to_id: HashMap = reference_names.iter().enumerate().map(|(i, s)| (s.clone(), i as i32)).collect(); let mut output_sam: Option>> = None; @@ -68,12 +71,12 @@ fn main() { let mut read_to_feature: Vec = Vec::new(); let mut counter = 0; - count_reads(bam, &mut counter, &mut counts, &args, gtf, &mut read_to_feature); + count_reads(reads_reader, &mut counter, &mut counts, &args, gtf, &mut read_to_feature); if args.output_sam.is_some() { eprintln!("Writing output sam file..."); // loop through the bam file again and write the reads to the output sam file - let bam = BamReader::from_path(args.bam.clone(), args.n).expect("Could not read bam file"); + let bam = ReadsReader::from_path(args.bam.clone(), args.n); for (i,record) in bam.enumerate() { let mut record = record.unwrap(); let feature = read_to_feature[i].as_bytes(); @@ -93,26 +96,77 @@ fn main() { } } +fn check_header_validity(header: &bam::Header, args: &Args) { + if header.lines().count() == 0 { + if args.bam.ends_with(".bam") { + eprintln!("The header of the bam file is empty. This is likely due to an invalid bam file."); + } else { + eprintln!("The header of the sam file is empty. This is likely due to an invalid sam file. (If you used samtools to convert a bam file to a sam file, make sure to use the -h option to include the header in the output file.)"); + std::process::exit(1); + } + } +} + +enum ReadsReader { + BamReader(BamReader), + SamReader(SamReader>), +} + +impl ReadsReader { + + fn from_path(path: String, n: u16) -> ReadsReader { + if path.ends_with(".bam") { + let reader = BamReader::from_path(path, n); + ReadsReader::BamReader(reader.unwrap()) + } else if path.ends_with(".sam") { + let reader = SamReader::from_path(path); + ReadsReader::SamReader(reader.unwrap()) + } else { + panic!("File type not supported"); + } + } + + fn header(&self) -> &bam::Header { + match self { + ReadsReader::BamReader(reader) => reader.header(), + ReadsReader::SamReader(reader) => reader.header(), + } + } +} + +impl Iterator for ReadsReader { + type Item = Result; + + fn next(&mut self) -> Option { + match self { + ReadsReader::BamReader(reader) => reader.next(), + ReadsReader::SamReader(reader) => reader.next(), + } + } +} + + + enum FeatureType { Name(String), - __no_feature, - __ambiguous(String), - __not_aligned, - __too_low_aQual, - __alignment_not_unique, - none, + NoFeature, + Ambiguous(String), + NotAligned, + TooLowaQual, + AlignmentNotUnique, + None, } impl FeatureType { fn as_bytes(&self) -> Vec { match self { FeatureType::Name(s) => s.as_bytes().to_vec(), - FeatureType::__no_feature => b"__no_feature".to_vec(), - FeatureType::__ambiguous(s) => format!("__ambiguous[{}]", s).as_bytes().to_vec(), - FeatureType::__not_aligned => b"__not_aligned".to_vec(), - FeatureType::__too_low_aQual => b"__too_low_aQual".to_vec(), - FeatureType::__alignment_not_unique => b"__alignment_not_unique".to_vec(), - FeatureType::none => b"".to_vec(), + FeatureType::NoFeature => b"__no_feature".to_vec(), + FeatureType::Ambiguous(s) => format!("__ambiguous[{}]", s).as_bytes().to_vec(), + FeatureType::NotAligned => b"__not_aligned".to_vec(), + FeatureType::TooLowaQual => b"__too_low_aQual".to_vec(), + FeatureType::AlignmentNotUnique => b"__alignment_not_unique".to_vec(), + FeatureType::None => b"".to_vec(), } } } @@ -334,30 +388,30 @@ fn should_skip_record( ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { - read_to_feature.push(FeatureType::__not_aligned); + read_to_feature.push(FeatureType::NotAligned); *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; return true; } // Skip all reads that are secondary alignments if args.secondary_alignments == "ignore" && record.flag().all_bits(0x100) { - read_to_feature.push(FeatureType::__not_aligned); + read_to_feature.push(FeatureType::NotAligned); return true; } // Skip all reads that are supplementary alignments if args.supplementary_alignments == "ignore" && record.flag().all_bits(0x800) { - read_to_feature.push(FeatureType::none); + read_to_feature.push(FeatureType::None); return true; } // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { - read_to_feature.push(FeatureType::__too_low_aQual); + read_to_feature.push(FeatureType::TooLowaQual); *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; return true; } // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { - read_to_feature.push(FeatureType::__alignment_not_unique); + read_to_feature.push(FeatureType::AlignmentNotUnique); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -425,7 +479,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut Vec) { +fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut Vec) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -489,7 +543,7 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap 1"); // construct partial reads for each cigar element with AlnMatch @@ -505,13 +559,13 @@ fn count_reads(bam: BamReader, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, counter: &mut i32, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { let mut feature = Feature::default(); let overlapping_features = features.overlap(start_pos, end_pos); @@ -554,7 +608,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb } else if overlapping_features.len() == 1 { feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); } else { - check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, &record, counts, read_to_feature); + check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, read_to_feature); } //todo!("process_partial_read"); @@ -562,7 +616,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb feature } -fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) { +fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) { let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); match feature_names.len() { 0 => {}, @@ -572,7 +626,7 @@ fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: let mut feature_names: Vec = feature_names.into_iter().collect(); feature_names.sort(); // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - read_to_feature.push(FeatureType::__ambiguous(feature_names.join("+"))); + read_to_feature.push(FeatureType::Ambiguous(feature_names.join("+"))); for feature_name in feature_names { *counts.entry(feature_name).or_insert(0) += 1; } @@ -635,10 +689,10 @@ fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, e } } -fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, record: &bam::Record, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From eeb389688974e078bc8060d729c827d0cbd421f4 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 12:55:49 +0100 Subject: [PATCH 27/52] Use separate thread to write the output sam file if necessary --- src/main.rs | 97 ++++++++++++++++++++++++++++++++--------------------- 1 file changed, 59 insertions(+), 38 deletions(-) diff --git a/src/main.rs b/src/main.rs index dc600bb..46b2d83 100755 --- a/src/main.rs +++ b/src/main.rs @@ -8,6 +8,8 @@ use std::cmp::{max, min}; use std::collections::{HashMap, HashSet}; use std::fs::File; use std::io::{BufRead, BufReader, BufWriter, Write}; +use std::sync::mpsc; +use std::thread; use structopt::StructOpt; mod feature; @@ -37,9 +39,24 @@ fn main() { let reference_names: Vec = header.reference_names().to_owned(); let ref_names_to_id: HashMap = reference_names.iter().enumerate().map(|(i, s)| (s.clone(), i as i32)).collect(); - let mut output_sam: Option>> = None; + + // Spawn a thread to write the output sam file + let (sender, receiver) = mpsc::channel::<(bam::Record, FeatureType)>(); + //let mut output_sam: Option>> = None; + // empty writer thread + let mut writer_thread = thread::spawn(|| {}); if args.output_sam.is_some() { - output_sam = Some(SamWriter::from_path(args.output_sam.clone().unwrap(), header).expect("Could not create output sam file")); + let output_sam = args.output_sam.clone().unwrap(); + writer_thread = thread::spawn(move || { + let mut output_sam = Some(SamWriter::from_path(output_sam ,header).expect("Could not create output sam file")); + for (mut record, type_) in receiver { + //eprintln!("Writing record to output sam file..."); + let feature = type_.as_bytes(); + record.tags_mut().push_string(b"XF", &feature); + output_sam.as_mut().unwrap().write(&record).unwrap(); + } + }); + //output_sam = Some(SamWriter::from_path(args.output_sam.clone().unwrap(), header).expect("Could not create output sam file")); } // bam fields: https://docs.rs/bam/0.3.0/bam/record/struct.Record.html @@ -68,27 +85,32 @@ fn main() { //std::process::exit(1); let mut counts = prepare_count_hashmap(>f); - let mut read_to_feature: Vec = Vec::new(); + //let mut read_to_feature: Vec = Vec::new(); let mut counter = 0; - count_reads(reads_reader, &mut counter, &mut counts, &args, gtf, &mut read_to_feature); + count_reads(reads_reader, &mut counter, &mut counts, &args, gtf, sender); - if args.output_sam.is_some() { - eprintln!("Writing output sam file..."); - // loop through the bam file again and write the reads to the output sam file - let bam = ReadsReader::from_path(args.bam.clone(), args.n); - for (i,record) in bam.enumerate() { - let mut record = record.unwrap(); - let feature = read_to_feature[i].as_bytes(); - record.tags_mut().push_string(b"XF", &feature); - output_sam.as_mut().unwrap().write(&record).unwrap(); - } + // if args.output_sam.is_some() { + // eprintln!("Writing output sam file..."); + // // loop through the bam file again and write the reads to the output sam file + // let bam = ReadsReader::from_path(args.bam.clone(), args.n); + // for (i,record) in bam.enumerate() { + // let mut record = record.unwrap(); + // let feature = read_to_feature[i].as_bytes(); + // record.tags_mut().push_string(b"XF", &feature); + // output_sam.as_mut().unwrap().write(&record).unwrap(); + // } - let mut output_sam = output_sam.unwrap(); - output_sam.flush().unwrap(); - output_sam.finish().unwrap(); + // let mut output_sam = output_sam.unwrap(); + // output_sam.flush().unwrap(); + // output_sam.finish().unwrap(); + // } + if args.output_sam.is_some() { + // wait for the writer thread to finish + writer_thread.join().unwrap(); } + if args.counts_output.is_some() { write_counts(counts, args, counter); } else { @@ -384,34 +406,34 @@ fn should_skip_record( record: &bam::Record, counts: &mut HashMap, args: &Args, - read_to_feature: &mut Vec, + sender: &mpsc::Sender<(bam::Record, FeatureType)>, ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { - read_to_feature.push(FeatureType::NotAligned); + _ = sender.send((record.clone(), FeatureType::NotAligned)); *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; return true; } // Skip all reads that are secondary alignments if args.secondary_alignments == "ignore" && record.flag().all_bits(0x100) { - read_to_feature.push(FeatureType::NotAligned); + _ = sender.send((record.clone(), FeatureType::None)); return true; } // Skip all reads that are supplementary alignments if args.supplementary_alignments == "ignore" && record.flag().all_bits(0x800) { - read_to_feature.push(FeatureType::None); + _ = sender.send((record.clone(), FeatureType::None)); return true; } // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { - read_to_feature.push(FeatureType::TooLowaQual); + _ = sender.send((record.clone(), FeatureType::TooLowaQual)); *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; return true; } // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { - read_to_feature.push(FeatureType::AlignmentNotUnique); + sender.send((record.clone(), FeatureType::AlignmentNotUnique)); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -479,7 +501,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, read_to_feature: &mut Vec) { +fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender<(bam::Record, FeatureType)>) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -500,7 +522,7 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap 1"); // construct partial reads for each cigar element with AlnMatch @@ -559,14 +581,14 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { let mut feature = Feature::default(); let overlapping_features = features.overlap(start_pos, end_pos); @@ -608,7 +630,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb } else if overlapping_features.len() == 1 { feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); } else { - check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, read_to_feature); + check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, &sender, record); } //todo!("process_partial_read"); @@ -616,7 +638,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb feature } -fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) { +fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) { let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); match feature_names.len() { 0 => {}, @@ -626,12 +648,11 @@ fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: let mut feature_names: Vec = feature_names.into_iter().collect(); feature_names.sort(); // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - read_to_feature.push(FeatureType::Ambiguous(feature_names.join("+"))); + sender.send((record.clone(), FeatureType::Ambiguous(feature_names.join("+")))); for feature_name in feature_names { *counts.entry(feature_name).or_insert(0) += 1; } - true } @@ -689,10 +710,10 @@ fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, e } } -fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, read_to_feature: &mut Vec) -> Feature { +fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From dd12946a8fd1568b8b427e329d7fbee3db9d53bf Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 12:56:32 +0100 Subject: [PATCH 28/52] _ unused variables for now to get rid of warnings --- src/main.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main.rs b/src/main.rs index 46b2d83..430a4fd 100755 --- a/src/main.rs +++ b/src/main.rs @@ -710,10 +710,10 @@ fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, e } } -fn process_intersection_nonempty_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { +fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender<(bam::Record, FeatureType)>, _record: &bam::Record) -> Feature { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { +fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender<(bam::Record, FeatureType)>, _record: &bam::Record) -> Feature { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From 64af5f463a14d413a2f393cc5b86d6e82d9b58b1 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 13:43:49 +0100 Subject: [PATCH 29/52] Refactor writer thread in main.rs --- src/main.rs | 41 +++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/src/main.rs b/src/main.rs index 430a4fd..fa672d0 100755 --- a/src/main.rs +++ b/src/main.rs @@ -43,21 +43,24 @@ fn main() { // Spawn a thread to write the output sam file let (sender, receiver) = mpsc::channel::<(bam::Record, FeatureType)>(); //let mut output_sam: Option>> = None; - // empty writer thread - let mut writer_thread = thread::spawn(|| {}); - if args.output_sam.is_some() { - let output_sam = args.output_sam.clone().unwrap(); - writer_thread = thread::spawn(move || { - let mut output_sam = Some(SamWriter::from_path(output_sam ,header).expect("Could not create output sam file")); + // by default, the writer thread does nothing and discards the input + let output_sam = args.output_sam.clone(); + let writer_thread = if output_sam.is_some() { + thread::spawn(move || { + let mut output_sam = SamWriter::from_path(output_sam.unwrap(), header).expect("Could not create output sam file"); for (mut record, type_) in receiver { - //eprintln!("Writing record to output sam file..."); let feature = type_.as_bytes(); record.tags_mut().push_string(b"XF", &feature); - output_sam.as_mut().unwrap().write(&record).unwrap(); + output_sam.write(&record).unwrap(); } - }); - //output_sam = Some(SamWriter::from_path(args.output_sam.clone().unwrap(), header).expect("Could not create output sam file")); - } + }) + } else { + thread::spawn(move || { + for _ in receiver { + // do nothing + } + }) + }; // bam fields: https://docs.rs/bam/0.3.0/bam/record/struct.Record.html // Read the gtf file @@ -106,11 +109,9 @@ fn main() { // output_sam.flush().unwrap(); // output_sam.finish().unwrap(); // } - if args.output_sam.is_some() { - // wait for the writer thread to finish - writer_thread.join().unwrap(); - } + writer_thread.join().unwrap(); + if args.counts_output.is_some() { write_counts(counts, args, counter); } else { @@ -433,7 +434,7 @@ fn should_skip_record( // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { - sender.send((record.clone(), FeatureType::AlignmentNotUnique)); + _ = sender.send((record.clone(), FeatureType::AlignmentNotUnique)); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -604,16 +605,16 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, _start_pos: let mut feature_names: Vec = feature_names.into_iter().collect(); feature_names.sort(); // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - sender.send((record.clone(), FeatureType::Ambiguous(feature_names.join("+")))); + _ = sender.send((record.clone(), FeatureType::Ambiguous(feature_names.join("+")))); for feature_name in feature_names { *counts.entry(feature_name).or_insert(0) += 1; } From 69640ace73db334b12c26fc270e3811bd96f1511 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 15:02:35 +0100 Subject: [PATCH 30/52] Improve samwriter to prevent cloning of features (now we read the input file twice, so if low reading speed, this might hurt a bit) --- src/main.rs | 51 +++++++++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 22 deletions(-) diff --git a/src/main.rs b/src/main.rs index fa672d0..57407d3 100755 --- a/src/main.rs +++ b/src/main.rs @@ -8,6 +8,7 @@ use std::cmp::{max, min}; use std::collections::{HashMap, HashSet}; use std::fs::File; use std::io::{BufRead, BufReader, BufWriter, Write}; +use std::iter::zip; use std::sync::mpsc; use std::thread; use structopt::StructOpt; @@ -41,15 +42,19 @@ fn main() { let ref_names_to_id: HashMap = reference_names.iter().enumerate().map(|(i, s)| (s.clone(), i as i32)).collect(); // Spawn a thread to write the output sam file - let (sender, receiver) = mpsc::channel::<(bam::Record, FeatureType)>(); + let (sender, receiver) = mpsc::channel::(); //let mut output_sam: Option>> = None; // by default, the writer thread does nothing and discards the input let output_sam = args.output_sam.clone(); + let input_reads = args.bam.clone(); let writer_thread = if output_sam.is_some() { thread::spawn(move || { let mut output_sam = SamWriter::from_path(output_sam.unwrap(), header).expect("Could not create output sam file"); - for (mut record, type_) in receiver { + let bam = ReadsReader::from_path(input_reads, args.n); + // read the + for (type_, record) in zip(receiver, bam) { let feature = type_.as_bytes(); + let mut record = record.unwrap(); record.tags_mut().push_string(b"XF", &feature); output_sam.write(&record).unwrap(); } @@ -109,7 +114,9 @@ fn main() { // output_sam.flush().unwrap(); // output_sam.finish().unwrap(); // } - + if args.output_sam.is_some() { + eprintln!("Waiting for writer thread to finish..."); + } writer_thread.join().unwrap(); if args.counts_output.is_some() { @@ -407,34 +414,34 @@ fn should_skip_record( record: &bam::Record, counts: &mut HashMap, args: &Args, - sender: &mpsc::Sender<(bam::Record, FeatureType)>, + sender: &mpsc::Sender, ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { - _ = sender.send((record.clone(), FeatureType::NotAligned)); + _ = sender.send(FeatureType::NotAligned); *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; return true; } // Skip all reads that are secondary alignments if args.secondary_alignments == "ignore" && record.flag().all_bits(0x100) { - _ = sender.send((record.clone(), FeatureType::None)); + _ = sender.send(FeatureType::None); return true; } // Skip all reads that are supplementary alignments if args.supplementary_alignments == "ignore" && record.flag().all_bits(0x800) { - _ = sender.send((record.clone(), FeatureType::None)); + _ = sender.send(FeatureType::None); return true; } // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { - _ = sender.send((record.clone(), FeatureType::TooLowaQual)); + _ = sender.send( FeatureType::TooLowaQual); *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; return true; } // Skip all reads that have an optional field "NH" with value > 1 if let Some(TagValue::Int(i, _)) = record.tags().get(b"NH") { if i > 1 { - _ = sender.send((record.clone(), FeatureType::AlignmentNotUnique)); + _ = sender.send( FeatureType::AlignmentNotUnique); *counts .entry("__alignment_not_unique".to_string()) .or_insert(0) += 1; @@ -502,7 +509,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender<(bam::Record, FeatureType)>) { +fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -566,7 +573,7 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap 1"); // construct partial reads for each cigar element with AlnMatch @@ -582,14 +589,14 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) -> Feature { +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender) -> Feature { let mut feature = Feature::default(); let overlapping_features = features.overlap(start_pos, end_pos); @@ -631,7 +638,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb } else if overlapping_features.len() == 1 { feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); } else { - check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, &sender, record); + check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, &sender); } //todo!("process_partial_read"); @@ -639,7 +646,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb feature } -fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender<(bam::Record, FeatureType)>, record: &bam::Record) { +fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender) { let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); match feature_names.len() { 0 => {}, @@ -649,7 +656,7 @@ fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: let mut feature_names: Vec = feature_names.into_iter().collect(); feature_names.sort(); // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - _ = sender.send((record.clone(), FeatureType::Ambiguous(feature_names.join("+")))); + _ = sender.send(FeatureType::Ambiguous(feature_names.join("+"))); for feature_name in feature_names { *counts.entry(feature_name).or_insert(0) += 1; } @@ -711,10 +718,10 @@ fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, e } } -fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender<(bam::Record, FeatureType)>, _record: &bam::Record) -> Feature { +fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender) -> Feature { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender<(bam::Record, FeatureType)>, _record: &bam::Record) -> Feature { +fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender) -> Feature { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From 724929a2beee4d3450bc8135a3ad6b70c174479c Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 15:49:53 +0100 Subject: [PATCH 31/52] Improvements suggested by clippy --- src/feature.rs | 14 +------------- src/interval.rs | 26 ++++++++++++-------------- src/intervaltree.rs | 2 +- src/main.rs | 14 +++++++------- src/node.rs | 39 +++++++++++++++++++++++++++------------ 5 files changed, 48 insertions(+), 47 deletions(-) diff --git a/src/feature.rs b/src/feature.rs index a704572..5918337 100644 --- a/src/feature.rs +++ b/src/feature.rs @@ -1,21 +1,9 @@ // Struct to store the features -#[derive(Debug, Eq, PartialEq, Hash, Clone)] +#[derive(Debug, Eq, PartialEq, Hash, Clone, Default)] pub struct Feature { //type_: String, pub name: String, pub chr: i32, pub start: i32, pub end: i32, -} - -// default implementation for Feature -impl Default for Feature { - fn default() -> Self { - Feature { - name: String::from(""), - chr: 0, - start: 0, - end: 0 - } - } } \ No newline at end of file diff --git a/src/interval.rs b/src/interval.rs index f94f22a..4c19738 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -44,24 +44,21 @@ impl Interval { pub fn distance_to(&self, other: &Interval) -> i32 { if self.overlaps(other) { 0 + } else if self.start > other.end { + self.start - other.end } else { - if self.start > other.end { - self.start - other.end - } else { - other.start - self.end - } + other.start - self.end } + } pub fn distance_to_point(&self, point: i32) -> i32 { if self.contains_point(point) { 0 + } else if self.start > point { + self.start - point } else { - if self.start > point { - self.start - point - } else { - point - self.end - } + point - self.end } } @@ -106,14 +103,15 @@ impl Interval { self.start >= other.start } + pub fn overlaps_with(&self, start: i32, end: i32) -> bool { + self.start < end && self.end-1 > start + } + } impl PartialOrd for Interval { fn partial_cmp(&self, other: &Self) -> Option { - // first by start, then by end, then by data.name (alphabetically) - Some(self.start.cmp(&other.start) - .then(self.end.cmp(&other.end)) - .then(self.data.as_ref().unwrap().name.cmp(&other.data.as_ref().unwrap().name))) + Some(self.cmp(other)) } } diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 93bf135..50206c3 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -45,7 +45,7 @@ impl IntervalTree { it.top_node.as_mut().unwrap().update_max_ends(); //eprintln!("added boundaries"); - return it; + it } else { IntervalTree { diff --git a/src/main.rs b/src/main.rs index 57407d3..3aac86b 100755 --- a/src/main.rs +++ b/src/main.rs @@ -47,9 +47,9 @@ fn main() { // by default, the writer thread does nothing and discards the input let output_sam = args.output_sam.clone(); let input_reads = args.bam.clone(); - let writer_thread = if output_sam.is_some() { + let writer_thread = if let Some(output_sam) = output_sam { thread::spawn(move || { - let mut output_sam = SamWriter::from_path(output_sam.unwrap(), header).expect("Could not create output sam file"); + let mut output_sam = SamWriter::from_path(output_sam, header).expect("Could not create output sam file"); let bam = ReadsReader::from_path(input_reads, args.n); // read the for (type_, record) in zip(receiver, bam) { @@ -374,7 +374,7 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa let feature = Feature { name: name.to_string(), - chr: chr_id.clone(), + chr: *chr_id, start: min(start, end), end: max(start, end), }; @@ -455,7 +455,7 @@ fn print_output(counts: HashMap, args: Args, counter: i32) { // Print de HashMap let mut sorted_keys: Vec<_> = counts.keys().collect(); // Sort the keys case-insensitively - sorted_keys.sort_by(|a, b| a.cmp(&b)); + sorted_keys.sort(); for key in sorted_keys { if key.starts_with("__") { continue; @@ -485,7 +485,7 @@ fn print_output(counts: HashMap, args: Args, counter: i32) { fn write_counts(counts: HashMap, args: Args, counter: i32) { let mut sorted_keys: Vec<_> = counts.keys().collect(); // Sort the keys case-insensitively - sorted_keys.sort_by(|a, b| a.cmp(&b)); + sorted_keys.sort(); let mut file = File::create(args.counts_output.unwrap()).expect("Unable to create file"); for key in sorted_keys { if key.starts_with("__") { @@ -573,7 +573,7 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap 1"); // construct partial reads for each cigar element with AlnMatch @@ -633,7 +633,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb let overlapping_features = features.overlap(start_pos, end_pos); - if overlapping_features.len() == 0 { + if overlapping_features.is_empty() { return feature; } else if overlapping_features.len() == 1 { feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); diff --git a/src/node.rs b/src/node.rs index eb77989..3789f2b 100644 --- a/src/node.rs +++ b/src/node.rs @@ -221,6 +221,26 @@ impl Node { result } + pub fn search_overlap_range(&self, start: i32, end: i32) -> HashSet<&Interval> { + let mut result = HashSet::new(); + for interval in &self.s_center { + if interval.overlaps_with(start, end) { + result.insert(interval); + } + } + if start < self.max_end_left { + if let Some(left_node) = &self.left_node { + result.extend(left_node.search_overlap_range(start, end)); + } + } + if end > self.x_center { + if let Some(right_node) = &self.right_node { + result.extend(right_node.search_overlap_range(start, end)); + } + } + result + } + pub fn search_point(&self, point: i32) -> HashSet<&Interval> { let mut result = HashSet::new(); for interval in &self.s_center { @@ -251,16 +271,11 @@ impl Node { return true; } } - if point < self.x_center { - if let Some(left_node) = &self.left_node { - return left_node.contains_point(point); - } - } else if point > self.x_center { - if let Some(right_node) = &self.right_node { - return right_node.contains_point(point); - } + match point.cmp(&self.x_center) { + std::cmp::Ordering::Equal => false, + std::cmp::Ordering::Less => return self.left_node.as_ref().map_or(false, |n| n.contains_point(point)), + std::cmp::Ordering::Greater => return self.right_node.as_ref().map_or(false, |n| n.contains_point(point)) } - false } pub fn all_children(&self) -> Vec { @@ -293,7 +308,7 @@ impl Node { let spaces = " ".repeat(indent); let mut result = vec![format!("{}{}", self, newline)]; - if self.s_center.len() > 0 { + if !self.s_center.is_empty() { for interval in &self.s_center { result.push(format!("{} {}{}", spaces, interval, newline)); } @@ -311,10 +326,10 @@ impl Node { let result = result.join(""); if to_string { - return vec![result] + vec![result] } else { println!("{}", result); - return vec![] + vec![] } } From d76fb75656b964dfff276054409d4b6c5f50402d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Tue, 6 Feb 2024 15:50:32 +0100 Subject: [PATCH 32/52] Fix function call in process_union_read --- src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index 3aac86b..716a473 100755 --- a/src/main.rs +++ b/src/main.rs @@ -638,7 +638,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, amb } else if overlapping_features.len() == 1 { feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); } else { - check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, &sender); + check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, sender); } //todo!("process_partial_read"); From 6e0383985b0ef4cabd2c9130ad24f9a8657c6e32 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 14:02:47 +0100 Subject: [PATCH 33/52] Make export_feature fully contained within node instead of having part in main --- src/main.rs | 4 +--- src/node.rs | 27 ++++++++++++++++++--------- 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/src/main.rs b/src/main.rs index 716a473..2442d25 100755 --- a/src/main.rs +++ b/src/main.rs @@ -83,9 +83,7 @@ fn main() { let mut file = File::create(args.export_feature_tree.clone().unwrap()).expect("Unable to create file"); for (chr, tree) in gtf.iter().enumerate() { // top node for each tree is the chromosome - file.write_all(format!("digraph {} {{\n", reference_names[chr]).as_bytes()).expect("Unable to write data"); - let _ = tree.as_ref().unwrap().top_node.clone().unwrap().write_structure(&mut file, 0); - file.write_all("}\n".as_bytes()).expect("Unable to write data"); + let _ = tree.as_ref().unwrap().top_node.clone().unwrap().write_structure(&mut file, 0, reference_names[chr].clone()); } } diff --git a/src/node.rs b/src/node.rs index 3789f2b..36c0d6c 100644 --- a/src/node.rs +++ b/src/node.rs @@ -334,20 +334,29 @@ impl Node { } - pub fn write_structure(&self, f: &mut File, indent: usize) -> std::fmt::Result { + pub fn write_structure(&self, f: &mut File, indent: usize, chr:String) -> std::fmt::Result { // write as dot file connected by edges - let newline = "\n"; - let spaces = " ".repeat(indent); + // if indent is 0, write the header + if indent==0 { + f.write_all(format!("digraph {} {{\n", chr).as_bytes()).expect("Unable to write data"); + } let current_data = self.s_center.iter().next().unwrap().data.as_ref().unwrap(); - let result = format!("{}{} [label=\"{}\n{}-{}\nmel: {}, mer: {}\"]{}", spaces, self.x_center,current_data.name, current_data.start, current_data.end, self.max_end_left, self.max_end_right, newline); - _ = write!(f, "{}", result); + // write the node + _ = writeln!(f, "{} [label=\"{}\n{}-{}\nmel: {}, mer: {}\"]", self.x_center,current_data.name, current_data.start, current_data.end, self.max_end_left, self.max_end_right); + // write the edges if they exist if let Some(left_node) = &self.left_node { - _ = write!(f, "{}{} -> {}{}", spaces, self.x_center, left_node.x_center, newline); - left_node.write_structure(f, indent)?; + _ = writeln!(f, "{} -> {}", self.x_center, left_node.x_center); + // Recursively write the left node + left_node.write_structure(f, indent+1, chr.clone())?; } if let Some(right_node) = &self.right_node { - _ = write!(f, "{}{} -> {}{}", spaces, self.x_center, right_node.x_center, newline); - right_node.write_structure(f, indent)?; + _ = write!(f, "{} -> {}", self.x_center, right_node.x_center); + // Recursively write the right node + right_node.write_structure(f, indent+1, chr)?; + } + // if indent is 0, write the footer + if indent==0 { + f.write_all("}".as_bytes()).expect("Unable to write data"); } Ok(()) } From c90b2e86421f4e6dcf9aa8d9f1ab841bcefa7313 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 14:11:46 +0100 Subject: [PATCH 34/52] Use read_into instead of iterating, to prevent new allocations (which is slower) --- src/main.rs | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/src/main.rs b/src/main.rs index 2442d25..2bfdf5d 100755 --- a/src/main.rs +++ b/src/main.rs @@ -12,6 +12,7 @@ use std::iter::zip; use std::sync::mpsc; use std::thread; use structopt::StructOpt; +use bam::RecordReader; mod feature; mod intervaltree; @@ -33,7 +34,7 @@ fn main() { } // Try to open the bam file, if it fails, print an error message - let reads_reader = ReadsReader::from_path(args.bam.clone(), args.n); + let mut reads_reader = ReadsReader::from_path(args.bam.clone(), args.n); let header = reads_reader.header().clone(); // check if the header is valid check_header_validity(&header, &args); @@ -94,7 +95,7 @@ fn main() { //let mut read_to_feature: Vec = Vec::new(); let mut counter = 0; - count_reads(reads_reader, &mut counter, &mut counts, &args, gtf, sender); + count_reads(&mut reads_reader, &mut counter, &mut counts, &args, gtf, sender); // if args.output_sam.is_some() { // eprintln!("Writing output sam file..."); @@ -160,6 +161,13 @@ impl ReadsReader { ReadsReader::SamReader(reader) => reader.header(), } } + + fn read_into(&mut self, record: &mut bam::Record) -> Result { + match self { + ReadsReader::BamReader(reader) => reader.read_into(record), + ReadsReader::SamReader(reader) => reader.read_into(record), + } + } } impl Iterator for ReadsReader { @@ -507,7 +515,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { +fn count_reads(bam: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -515,15 +523,20 @@ fn count_reads(bam: ReadsReader, counter: &mut i32, counts: &mut HashMap process_union_read, _ => panic!("Invalid mode"), }; - - for record in bam { + let mut record = bam::Record::new(); + loop { + match bam.read_into(&mut record) { + Ok(true) => {}, + Ok(false) => break, + Err(e) => panic!("{}", e), + } + //for record in bam { //eprintln!("{} records processed.", counter); *counter += 1; if *counter % 100000 == 0 { //println!("{} records processed.", counter); eprintln!("{} records processed.", counter); } - let record = record.unwrap(); // if String::from_utf8_lossy(record.name())=="SRR001432.281211 USI-EAS21_0008_3445:8:7:657:535 length=25" { // //println!("{}: {}-{}", String::from_utf8_lossy(record.name()), record.start(), record.calculate_end()); // eprintln!("this one"); From 6f084d2b9a4668956750247929c8ebf0017fc3f3 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 14:26:36 +0100 Subject: [PATCH 35/52] Fix imports and rename variable in count_reads function --- src/main.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/main.rs b/src/main.rs index 2bfdf5d..0325eac 100755 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,6 @@ use bam::record::cigar::Operation; use bam::record::tags::TagValue; -use bam::{BamReader, RecordWriter, SamReader, SamWriter}; +use bam::{RecordReader,BamReader, RecordWriter, SamReader, SamWriter}; use feature::Feature; use intervaltree::IntervalTree; use interval::Interval; @@ -12,7 +12,6 @@ use std::iter::zip; use std::sync::mpsc; use std::thread; use structopt::StructOpt; -use bam::RecordReader; mod feature; mod intervaltree; @@ -515,7 +514,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(bam: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { +fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, @@ -525,7 +524,7 @@ fn count_reads(bam: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap {}, Ok(false) => break, Err(e) => panic!("{}", e), From d290747993520b3ed265a91aed0f400c2b8e0594 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 17:04:42 +0100 Subject: [PATCH 36/52] Change 'XS' tag type from A to Z to match htseq-count --- src/main.rs | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/main.rs b/src/main.rs index 0325eac..4db3630 100755 --- a/src/main.rs +++ b/src/main.rs @@ -55,6 +55,38 @@ fn main() { for (type_, record) in zip(receiver, bam) { let feature = type_.as_bytes(); let mut record = record.unwrap(); + + // if 'XS' tag (strandedness) already exists, change the type from A (character) to Z (string) // else, do nothing + // we change this tag from A to Z because htseqcount does this as well + // TODO: check if we need to support this or not since it is extra work, for no obvious reason + if let Some(_) = record.tags().get(b"XS") { + //get a copy from all tags + let tags = record.tags().clone(); + // clear the old tags + record.tags_mut().clear(); + // add the old tags back, but change the type of the XS tag to Z + for (key, value) in tags.iter() { + match value { + TagValue::Char(c) => { + if key == *b"XS" { + // note: c = + or -, but are represented as 43 and 45 in ASCII + record.tags_mut().push_string(b"XS", &vec![c as u8]); + } else { + record.tags_mut().push_char(&key, c); + } + } + TagValue::Int(i, _t) => record.tags_mut().push_num(&key, i as i32), + TagValue::Float(f) => record.tags_mut().push_num(&key, f), + TagValue::String(s, _t) => record.tags_mut().push_string(&key, s), + TagValue::FloatArray(a) => record.tags_mut().push_array(&key, a.raw()), + TagValue::IntArray(a) => record.tags_mut().push_array(&key, a.raw()), + } + } + + //eprintln!("tags: {:?}", record.tags().raw()); + } + + // push also the feature to the XF tag record.tags_mut().push_string(b"XF", &feature); output_sam.write(&record).unwrap(); } From 3c228e8b61bda675348878edd6021ab48b8bd544 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 21:44:36 +0100 Subject: [PATCH 37/52] Simplify, fix and improve counting with regards to ambiguous features! --- src/main.rs | 206 +++++++++++++++------------------------------------- 1 file changed, 60 insertions(+), 146 deletions(-) diff --git a/src/main.rs b/src/main.rs index 4db3630..48e9b07 100755 --- a/src/main.rs +++ b/src/main.rs @@ -7,8 +7,7 @@ use interval::Interval; use std::cmp::{max, min}; use std::collections::{HashMap, HashSet}; use std::fs::File; -use std::io::{BufRead, BufReader, BufWriter, Write}; -use std::iter::zip; +use std::io::{BufRead, BufReader, Write}; use std::sync::mpsc; use std::thread; use structopt::StructOpt; @@ -50,11 +49,16 @@ fn main() { let writer_thread = if let Some(output_sam) = output_sam { thread::spawn(move || { let mut output_sam = SamWriter::from_path(output_sam, header).expect("Could not create output sam file"); - let bam = ReadsReader::from_path(input_reads, args.n); + let mut bam = ReadsReader::from_path(input_reads, args.n); // read the - for (type_, record) in zip(receiver, bam) { + let mut record= bam::Record::new(); + for type_ in receiver { + record = match bam.read_into(&mut record) { + Ok(true) => record, + Ok(false) => break, + Err(e) => panic!("{}", e), + }; let feature = type_.as_bytes(); - let mut record = record.unwrap(); // if 'XS' tag (strandedness) already exists, change the type from A (character) to Z (string) // else, do nothing // we change this tag from A to Z because htseqcount does this as well @@ -585,79 +589,62 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H let end_pos = record.calculate_end() + 1; let features = >f[ref_id].as_ref().unwrap(); - let mut ambiguous = false; - - // case 1: read is fully within feature -> count feature - // RRR - //AAAAAAAAA - // case 2: read is partially within feature -> don't count feature - // RRRRR - //AAAAAAAAA - // case 3: read overspans intron -> don't count feature - // RRRRRR - //AAAAIIAAAA - // case 4: read is split over two exons (of same gene) -> count feature - // RR--RR - //AAAAIIAAAA - // case 5: read is overlaps with two genes, but only one gene covers the entire read -> count feature for that gene - // RRR - //AAAAAAA - // BBBBBBB - // case 6: read is overlaps with two genes, but both genes cover the entire read -> ambiguous - // RRR - //AAAAAAA - //BBBBBBB - // if cigar has length 1 and is a match, we can use the start and end positions of the read let cigar = record.cigar(); - let mut feature = Feature::default(); + let mut overlapping_features: Vec = Vec::new(); + //let mut ambiguous = false; if cigar.len() == 1 && cigar.iter().next().unwrap().1 == Operation::AlnMatch { //eprintln!("startindex: {}, endindex: {}", startindex, endindex); - feature = processing_function(features, start_pos, end_pos, &mut ambiguous, counts, &sender); + processing_function(features, start_pos, end_pos, &mut overlapping_features); + //ambiguous = check_ambiguity_union(overlapping_features); } else { - //todo!("cigar length > 1"); - // construct partial reads for each cigar element with AlnMatch - // keep track of feature_names for each partial read, if they are all the same, we can count the feature let mut start_pos = start_pos; - // if cigar has length > 1, we need to check each cigar element for cig in cigar.iter() { if cig.1 != Operation::AlnMatch { // Skip all cigar elements that are not matches, but add the length to the start position - start_pos += cig.0 as i32; + // Soft clips are not added to the start position + if cig.1 != Operation::Soft { + start_pos += cig.0 as i32; + } continue; } - let partial_end_pos = start_pos + cig.0 as i32; + let partial_end_pos = start_pos + cig.0 as i32 +1 ; - let temp_feature_name = processing_function(features, start_pos, partial_end_pos, &mut ambiguous, counts, &sender); - // if ambiguous flag is set, we can stop here, otherwise we can add the feature name to the list - if ambiguous { - break; - } else if feature != Feature::default() && feature.name != temp_feature_name.name { - check_ambiguity_union(&features.overlap(start_pos, partial_end_pos), - start_pos, partial_end_pos, &mut feature, &mut ambiguous, - counts, &sender); - if ambiguous { - break; - } - } - else { - feature = temp_feature_name; - } - start_pos = partial_end_pos+1; + processing_function(features, start_pos, partial_end_pos, &mut overlapping_features); + start_pos = partial_end_pos; } } - if ambiguous { - *counts.entry("__ambiguous".to_string()).or_insert(0) += 1; - } else if feature.name == String::default() { - *counts.entry("__no_feature".to_string()).or_insert(0) += 1; - _ = sender.send(FeatureType::NoFeature); - } else { - *counts.entry(feature.name.clone()).or_insert(0) += 1; - _ = sender.send(FeatureType::Name(feature.name)); + // get the unique feature_names from the overlapping features, also filter out the empty names + let mut unique_feature_names= filter_ambiguity_union(&overlapping_features); + + // match based on the amount of unique feature names + let feature_name_len = unique_feature_names.len(); + match feature_name_len { + 0 => { + // if there are no unique feature names, we have no feature + *counts.entry("__no_feature".to_string()).or_insert(0) += 1; + _ = sender.send(FeatureType::NoFeature); + }, + 1 => { + // if there is only one unique feature name, we have a non-ambiguous read + let feature_name = unique_feature_names.iter().next().unwrap(); + *counts.entry(feature_name.clone()).or_insert(0) += 1; + _ = sender.send(FeatureType::Name(feature_name.clone())); + }, + _ => { + // if there are multiple unique feature names, we have an ambiguous read + *counts.entry("__ambiguous".to_string()).or_insert(0) += 1; + // we also increment each feature name by 1 + for feature_name in unique_feature_names.clone() { + *counts.entry(feature_name.clone()).or_insert(0) += 1; + } + unique_feature_names.sort(); + _ = sender.send(FeatureType::Ambiguous(unique_feature_names.join("+"))); + } } } else { // No reference found for this read @@ -670,100 +657,27 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H eprintln!("{} records processed.", counter); } -fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender) -> Feature { - let mut feature = Feature::default(); - - let overlapping_features = features.overlap(start_pos, end_pos); - - if overlapping_features.is_empty() { - return feature; - } else if overlapping_features.len() == 1 { - feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); - } else { - check_ambiguity_union(&overlapping_features, start_pos, end_pos, &mut feature, ambiguous, counts, sender); - } - - //todo!("process_partial_read"); - - feature -} - -fn check_ambiguity_union(overlapping_features: &HashSet<&Interval>, _start_pos: i32, _end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, counts: &mut HashMap, sender: &mpsc::Sender) { - let feature_names: HashSet = overlapping_features.iter().map(|f| f.data.as_ref().unwrap().name.clone()).collect(); - match feature_names.len() { - 0 => {}, - 1 => *feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(), - _ => *ambiguous = { - //use feature_names as the ambiguous feature - let mut feature_names: Vec = feature_names.into_iter().collect(); - feature_names.sort(); - // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - _ = sender.send(FeatureType::Ambiguous(feature_names.join("+"))); - for feature_name in feature_names { - *counts.entry(feature_name).or_insert(0) += 1; - } - - true - } - +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, overlapping_features: &mut Vec) { + let new_overlap = features.overlap(start_pos, end_pos); + // add all overlapping features to the list + for overlap in new_overlap { + let feature = overlap.data.as_ref().unwrap(); + overlapping_features.push(feature.clone()); } } +fn filter_ambiguity_union( + overlapping_features: &Vec, +) -> Vec { + let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name.clone()).filter(|x| !x.is_empty()).collect(); + unique_feature_names.into_iter().collect() -fn _check_ambiguity(overlapping_features: &HashSet<&Interval>, start_pos: i32, end_pos: i32, feature: &mut Feature, ambiguous: &mut bool, output_sam: &mut Option>>, record: &bam::Record) { - let mut contained_by = Vec::new(); - for overlap in overlapping_features { - if overlap.start <= start_pos && overlap.end >= end_pos { - contained_by.push(overlap.data.as_ref().unwrap().clone()); - } - } - - let feature_names: HashSet = contained_by.iter().map(|f| f.name.clone()).collect(); - - match feature_names.len() { - 0 => *ambiguous = { - // get overlapping_features names - let mut names = HashSet::new(); - for overlap in overlapping_features { - names.insert(overlap.data.as_ref().unwrap().name.clone()); - } - if names.len() == 1 { - *feature = overlapping_features.iter().next().unwrap().data.as_ref().unwrap().clone(); - false - } else { - // sort alphabetically - let mut names: Vec = names.into_iter().collect(); - names.sort(); - - // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - if let Some(output_sam) = output_sam { - let mut record = record.clone(); - record.tags_mut().push_string(b"XF", format!("__ambiguous[{}]", names.join("+")).as_bytes()); - output_sam.write(&record).unwrap(); - } - true - } - }, - 1 => *feature = contained_by[0].clone(), - _ => *ambiguous = { - //use feature_names as the ambiguous feature - let mut feature_names: Vec = feature_names.into_iter().collect(); - feature_names.sort(); - // write XF:Z:__ambiguous[feature_names] to the tags of the record and write it to the output sam file (separator: +) - if let Some(output_sam) = output_sam { - let mut record = record.clone(); - record.tags_mut().push_string(b"XF", format!("__ambiguous[{}]", feature_names.join("+")).as_bytes()); - output_sam.write(&record).unwrap(); - } - true - } - } } -fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender) -> Feature { +fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _overlapping_features: &mut Vec) { todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _ambiguous: &mut bool, _counts: &mut HashMap, _sender: &mpsc::Sender) -> Feature { +fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _overlapping_features: &mut Vec) { todo!("process_partial_read for intersection-strict"); } \ No newline at end of file From b43357228e605d332edc44947085316643824425 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 21:45:17 +0100 Subject: [PATCH 38/52] create a custom diff because with large files i get OOM error :'( --- diff.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 diff.py diff --git a/diff.py b/diff.py new file mode 100644 index 0000000..fa98f39 --- /dev/null +++ b/diff.py @@ -0,0 +1,12 @@ +#!/usr/bin/python + +import sys + +file1 = sys.argv[1] +file2 = sys.argv[2] + +with open(file1, 'r') as f1, open(file2, 'r') as f2: + for line1, line2 in zip(f1, f2): + if line1 != line2: + # split the lines on tab, print the first, fourth, sixth and last fields side by side for each file + print('\t'.join([line1.split('\t')[0], line1.split('\t')[3], line1.split('\t')[5], line1.split('\t')[-1].strip()]), '\t', line2.split('\t')[-1].strip()) \ No newline at end of file From 05e15048478789fd8a4af5fb4852c413b073ac26 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 22:13:54 +0100 Subject: [PATCH 39/52] Refactor count_reads function to improve readability and remove unnecessary code --- src/main.rs | 46 +++++++++++++--------------------------------- 1 file changed, 13 insertions(+), 33 deletions(-) diff --git a/src/main.rs b/src/main.rs index 48e9b07..c03d729 100755 --- a/src/main.rs +++ b/src/main.rs @@ -551,7 +551,6 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { - let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, "intersection-nonempty" => process_intersection_nonempty_read, @@ -572,50 +571,31 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H //println!("{} records processed.", counter); eprintln!("{} records processed.", counter); } - // if String::from_utf8_lossy(record.name())=="SRR001432.281211 USI-EAS21_0008_3445:8:7:657:535 length=25" { - // //println!("{}: {}-{}", String::from_utf8_lossy(record.name()), record.start(), record.calculate_end()); - // eprintln!("this one"); - // } if should_skip_record(&record, counts, args, &sender) { continue; } - // todo - //unimplemented!("todo"); let ref_id = record.ref_id() as usize; if gtf[ref_id].is_some() { - let start_pos = record.start(); - let end_pos = record.calculate_end() + 1; + let mut start_pos = record.start(); + //let end_pos = record.calculate_end() + 1; let features = >f[ref_id].as_ref().unwrap(); - - - // if cigar has length 1 and is a match, we can use the start and end positions of the read let cigar = record.cigar(); let mut overlapping_features: Vec = Vec::new(); - //let mut ambiguous = false; - if cigar.len() == 1 && cigar.iter().next().unwrap().1 == Operation::AlnMatch { - - //eprintln!("startindex: {}, endindex: {}", startindex, endindex); - processing_function(features, start_pos, end_pos, &mut overlapping_features); - //ambiguous = check_ambiguity_union(overlapping_features); - } else { - let mut start_pos = start_pos; - // if cigar has length > 1, we need to check each cigar element - for cig in cigar.iter() { - if cig.1 != Operation::AlnMatch { - // Skip all cigar elements that are not matches, but add the length to the start position - // Soft clips are not added to the start position - if cig.1 != Operation::Soft { - start_pos += cig.0 as i32; - } - continue; + for cig in cigar.iter() { + if cig.1 != Operation::AlnMatch { + // Skip all cigar elements that are not matches, but add the length to the start position + // Soft clips are not added to the start position + if cig.1 != Operation::Soft { + start_pos += cig.0 as i32; } - let partial_end_pos = start_pos + cig.0 as i32 +1 ; - - processing_function(features, start_pos, partial_end_pos, &mut overlapping_features); - start_pos = partial_end_pos; + continue; } + let partial_end_pos = start_pos + cig.0 as i32 +1 ; + + processing_function(features, start_pos, partial_end_pos, &mut overlapping_features); + start_pos = partial_end_pos; } // get the unique feature_names from the overlapping features, also filter out the empty names From 2bff9fb16fc591a72b96cf224d82420e8473011f Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Wed, 7 Feb 2024 22:29:15 +0100 Subject: [PATCH 40/52] Refactor code to use is_some() instead of pattern matching in main.rs --- src/main.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main.rs b/src/main.rs index c03d729..11e702d 100755 --- a/src/main.rs +++ b/src/main.rs @@ -63,7 +63,7 @@ fn main() { // if 'XS' tag (strandedness) already exists, change the type from A (character) to Z (string) // else, do nothing // we change this tag from A to Z because htseqcount does this as well // TODO: check if we need to support this or not since it is extra work, for no obvious reason - if let Some(_) = record.tags().get(b"XS") { + if record.tags().get(b"XS").is_some() { //get a copy from all tags let tags = record.tags().clone(); // clear the old tags @@ -74,7 +74,7 @@ fn main() { TagValue::Char(c) => { if key == *b"XS" { // note: c = + or -, but are represented as 43 and 45 in ASCII - record.tags_mut().push_string(b"XS", &vec![c as u8]); + record.tags_mut().push_string(b"XS", &[c]); } else { record.tags_mut().push_char(&key, c); } @@ -611,7 +611,7 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H }, 1 => { // if there is only one unique feature name, we have a non-ambiguous read - let feature_name = unique_feature_names.iter().next().unwrap(); + let feature_name = unique_feature_names.first().unwrap(); *counts.entry(feature_name.clone()).or_insert(0) += 1; _ = sender.send(FeatureType::Name(feature_name.clone())); }, @@ -647,7 +647,7 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, ove } fn filter_ambiguity_union( - overlapping_features: &Vec, + overlapping_features: &[Feature], ) -> Vec { let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name.clone()).filter(|x| !x.is_empty()).collect(); unique_feature_names.into_iter().collect() From c33ded0db86a331e6845f8e35979f32e19e22580 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 16:55:32 +0100 Subject: [PATCH 41/52] Refactor overlap function to return Vec instead of HashSet --- src/intervaltree.rs | 4 ++-- src/node.rs | 10 +++------- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 50206c3..8985bd7 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -286,10 +286,10 @@ impl IntervalTree { false } - pub fn overlap(&self, start: i32, end: i32) -> HashSet<&Interval> { + pub fn overlap(&self, start: i32, end: i32) -> Vec<&Interval> { // return a vector of all intervals that overlap with the given range if self.is_empty() || start >= end { - return HashSet::new(); + return Vec::new(); } let root = self.top_node.as_ref().unwrap(); let mut result = root.search_point(start); diff --git a/src/node.rs b/src/node.rs index 36c0d6c..bf3b97d 100644 --- a/src/node.rs +++ b/src/node.rs @@ -241,23 +241,19 @@ impl Node { result } - pub fn search_point(&self, point: i32) -> HashSet<&Interval> { - let mut result = HashSet::new(); + pub fn search_point(&self, point: i32) -> Vec<&Interval> { + let mut result = Vec::new(); for interval in &self.s_center { if interval.contains_point(point) { - // print in red - //eprintln!("\x1b[31mFound interval: {:?}\x1b[0m", interval); - result.insert(interval); + result.push(interval); } } if point < self.max_end_left { if let Some(left_node) = &self.left_node { - //eprintln!("\x1b[32mx_center: {}, Going to the left, Data: {:?}", self.x_center, self.s_center); result.extend(left_node.search_point(point)); } } if point > self.x_center { - //eprintln!("\x1b[33mx_center: {}, Going to the right, Data: {:?}", self.x_center, self.s_center); if let Some(right_node) = &self.right_node { result.extend(right_node.search_point(point)); } From acd1b93a73561260d5d95e2795fa04125b01c607 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 19:33:25 +0100 Subject: [PATCH 42/52] Change interval comparison to be start and end inclusive and remove unnecessary code --- src/interval.rs | 10 +++++----- src/intervaltree.rs | 14 +++++++------- src/node.rs | 4 ++-- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/interval.rs b/src/interval.rs index 4c19738..ff4c3e8 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -30,7 +30,7 @@ impl Interval { } pub fn contains_point(&self, point: i32) -> bool { - self.start <= point && point < self.end-1 + self.start <= point && point <= self.end } pub fn range_matches(&self, other: &Interval) -> bool { @@ -118,10 +118,10 @@ impl PartialOrd for Interval { impl Ord for Interval { fn cmp(&self, other: &Self) -> std::cmp::Ordering { // check if both intervals are not null - if self.is_null() || other.is_null() { - // throw error - panic!("Cannot compare null intervals"); - } + // if self.is_null() || other.is_null() { + // // throw error + // panic!("Cannot compare null intervals"); + // } // first by start, then by end, then by data.name (alphabetically) self.start.cmp(&other.start) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 8985bd7..4b016a2 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -26,11 +26,11 @@ impl IntervalTree { //let unique_intervals: Vec = unique_intervals.into_iter().collect(); //eprintln!("filtered intervals"); // check if intervals are not null - for interval in &unique_intervals { - if interval.is_null() { - panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree: {:?}", interval); - } - } + // for interval in &unique_intervals { + // if interval.is_null() { + // panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree: {:?}", interval); + // } + // } let mut it = IntervalTree { all_intervals: unique_intervals.clone(), top_node: Node::from_intervals(unique_intervals.clone()), @@ -288,12 +288,12 @@ impl IntervalTree { pub fn overlap(&self, start: i32, end: i32) -> Vec<&Interval> { // return a vector of all intervals that overlap with the given range - if self.is_empty() || start >= end { + if self.is_empty() || start > end { return Vec::new(); } let root = self.top_node.as_ref().unwrap(); let mut result = root.search_point(start); - for (&key, _) in self.boundary_table.range(start..end) { + for (&key, _) in self.boundary_table.range(start..end+1) { result.extend(root.search_point(key)); } result diff --git a/src/node.rs b/src/node.rs index bf3b97d..8e70e1f 100644 --- a/src/node.rs +++ b/src/node.rs @@ -248,12 +248,12 @@ impl Node { result.push(interval); } } - if point < self.max_end_left { + if point <= self.max_end_left { if let Some(left_node) = &self.left_node { result.extend(left_node.search_point(point)); } } - if point > self.x_center { + if point >= self.x_center { if let Some(right_node) = &self.right_node { result.extend(right_node.search_point(point)); } From 1b44e8e32369dc24472b659f3a28a07ce1f18eee Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 19:34:48 +0100 Subject: [PATCH 43/52] Refactor code to remove commented out code and finally fix all overlap checks for test file --- src/main.rs | 46 ++++++++++++++++++++++------------------------ 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/src/main.rs b/src/main.rs index 11e702d..9b75ba7 100755 --- a/src/main.rs +++ b/src/main.rs @@ -131,23 +131,7 @@ fn main() { let mut counter = 0; count_reads(&mut reads_reader, &mut counter, &mut counts, &args, gtf, sender); - - // if args.output_sam.is_some() { - // eprintln!("Writing output sam file..."); - // // loop through the bam file again and write the reads to the output sam file - // let bam = ReadsReader::from_path(args.bam.clone(), args.n); - // for (i,record) in bam.enumerate() { - // let mut record = record.unwrap(); - // let feature = read_to_feature[i].as_bytes(); - // record.tags_mut().push_string(b"XF", &feature); - // output_sam.as_mut().unwrap().write(&record).unwrap(); - // } - - - // let mut output_sam = output_sam.unwrap(); - // output_sam.flush().unwrap(); - // output_sam.finish().unwrap(); - // } + if args.output_sam.is_some() { eprintln!("Waiting for writer thread to finish..."); } @@ -396,7 +380,7 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa let start = fields.next().unwrap().parse::().unwrap(); - let end = fields.next().unwrap().parse::().unwrap()+1; + let end = fields.next().unwrap().parse::().unwrap(); if feature_name != feature_type_filter { line.clear(); @@ -558,7 +542,9 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H _ => panic!("Invalid mode"), }; let mut record = bam::Record::new(); + let mut overlapping_features: Vec = Vec::with_capacity(50); loop { + overlapping_features.clear(); match reads_reader.read_into(&mut record) { Ok(true) => {}, Ok(false) => break, @@ -578,23 +564,35 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H let ref_id = record.ref_id() as usize; if gtf[ref_id].is_some() { - let mut start_pos = record.start(); + let mut start_pos = record.start() +1; //let end_pos = record.calculate_end() + 1; let features = >f[ref_id].as_ref().unwrap(); let cigar = record.cigar(); - let mut overlapping_features: Vec = Vec::new(); for cig in cigar.iter() { if cig.1 != Operation::AlnMatch { // Skip all cigar elements that are not matches, but add the length to the start position // Soft clips are not added to the start position - if cig.1 != Operation::Soft { - start_pos += cig.0 as i32; + /* if record.name() == "SRR5724993.43083906".to_string().as_bytes(){ + + eprintln!("start_pos: {}, cig:{:?}", start_pos, cig); + } */ + match cig.1 { + Operation::Soft => {}, + Operation::Insertion => start_pos += 1, + _ => start_pos += cig.0 as i32 + 1, } continue; } - let partial_end_pos = start_pos + cig.0 as i32 +1 ; - + let partial_end_pos = start_pos + cig.0 as i32 -1 ; + /* if record.name() == "SRR5724993.43083906".to_string().as_bytes(){ + + eprintln!("start_pos: {}, end_pos: {}, cig:{:?}", start_pos, partial_end_pos, cig); + } + */ processing_function(features, start_pos, partial_end_pos, &mut overlapping_features); + /* if record.name() == "SRR5724993.43083906".to_string().as_bytes(){ + eprintln!("overlapping_features: {:?}", overlapping_features); + } */ start_pos = partial_end_pos; } From b684f706c05575217fbf223178bdd0e0232f1aac Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 19:35:11 +0100 Subject: [PATCH 44/52] Refactor line splitting in diff.py for improved readability (and speed?) --- diff.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/diff.py b/diff.py index fa98f39..bf84311 100644 --- a/diff.py +++ b/diff.py @@ -8,5 +8,6 @@ with open(file1, 'r') as f1, open(file2, 'r') as f2: for line1, line2 in zip(f1, f2): if line1 != line2: + spline1 = line1.split('\t') # split the lines on tab, print the first, fourth, sixth and last fields side by side for each file - print('\t'.join([line1.split('\t')[0], line1.split('\t')[3], line1.split('\t')[5], line1.split('\t')[-1].strip()]), '\t', line2.split('\t')[-1].strip()) \ No newline at end of file + print('\t'.join([spline1[0], spline1[2], spline1[3], spline1[5], spline1[-1].strip()]), '\t', line2.split('\t')[-1].strip()) \ No newline at end of file From 5bc54d258a9c8020f43a290a458473082fc920db Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 22:00:53 +0100 Subject: [PATCH 45/52] Add dependency: random --- Cargo.lock | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Cargo.toml | 3 ++- 2 files changed, 56 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index aedee2e..09d5eb5 100755 --- a/Cargo.lock +++ b/Cargo.lock @@ -91,6 +91,17 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "getrandom" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + [[package]] name = "heck" version = "0.3.3" @@ -114,6 +125,7 @@ name = "htseq_count_rust" version = "0.1.0" dependencies = [ "bam", + "rand", "structopt", ] @@ -138,6 +150,12 @@ dependencies = [ "adler", ] +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + [[package]] name = "proc-macro-error" version = "1.0.4" @@ -180,6 +198,36 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + [[package]] name = "strsim" version = "0.8.0" @@ -260,6 +308,12 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + [[package]] name = "winapi" version = "0.3.9" diff --git a/Cargo.toml b/Cargo.toml index a4e091f..1aee966 100755 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,4 +7,5 @@ edition = "2021" [dependencies] structopt = "0.3" -bam = "0.1.4" \ No newline at end of file +bam = "0.1.4" +rand = "0.8.5" \ No newline at end of file From a2f40b99cbd81752d8395a42aab0e23945ac951f Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 22:01:13 +0100 Subject: [PATCH 46/52] Refactor Feature struct and add new methods --- src/feature.rs | 43 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/src/feature.rs b/src/feature.rs index 5918337..65e3885 100644 --- a/src/feature.rs +++ b/src/feature.rs @@ -1,9 +1,44 @@ +#![allow(dead_code)] + // Struct to store the features #[derive(Debug, Eq, PartialEq, Hash, Clone, Default)] pub struct Feature { //type_: String, - pub name: String, - pub chr: i32, - pub start: i32, - pub end: i32, + name: String, + chr: i32, + start: i32, + end: i32, + strand: char, +} + +impl Feature { + pub fn new(name: String, chr: i32, start: i32, end: i32, strand: char) -> Self { + Feature { + name, + chr, + start, + end, + strand, + } + } + + pub fn name(&self) -> &str { + &self.name + } + + pub fn chr(&self) -> i32 { + self.chr + } + + pub fn start(&self) -> i32 { + self.start + } + + pub fn end(&self) -> i32 { + self.end + } + + pub fn strand(&self) -> char { + self.strand + } } \ No newline at end of file From f086366f534ac7a4eda5d3e1bef253386914aa01 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 22:01:26 +0100 Subject: [PATCH 47/52] Fix comparison of interval names in Ord and Display implementations --- src/interval.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/interval.rs b/src/interval.rs index ff4c3e8..2b362d3 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -126,7 +126,7 @@ impl Ord for Interval { // first by start, then by end, then by data.name (alphabetically) self.start.cmp(&other.start) .then(self.end.cmp(&other.end)) - .then(self.data.as_ref().unwrap().name.cmp(&other.data.as_ref().unwrap().name)) + .then(self.data.as_ref().unwrap().name().cmp(&other.data.as_ref().unwrap().name())) } } @@ -134,7 +134,7 @@ impl Ord for Interval { impl std::fmt::Display for Interval { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { match &self.data { - Some(feature) => write!(f, "Interval({}, {}, {})", self.start, self.end, feature.name), + Some(feature) => write!(f, "Interval({}, {}, {})", self.start, self.end, feature.name()), None => write!(f, "Interval({}, {})", self.start, self.end), } } From 850a19a4b6d86fb621b2337b1c8419aa6d54780f Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 22:01:33 +0100 Subject: [PATCH 48/52] Fix function calls in node.rs --- src/node.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/node.rs b/src/node.rs index 8e70e1f..5b72fb2 100644 --- a/src/node.rs +++ b/src/node.rs @@ -338,7 +338,7 @@ impl Node { } let current_data = self.s_center.iter().next().unwrap().data.as_ref().unwrap(); // write the node - _ = writeln!(f, "{} [label=\"{}\n{}-{}\nmel: {}, mer: {}\"]", self.x_center,current_data.name, current_data.start, current_data.end, self.max_end_left, self.max_end_right); + _ = writeln!(f, "{} [label=\"{}\n{}-{}\nmel: {}, mer: {}\"]", self.x_center,current_data.name(), current_data.start(), current_data.end(), self.max_end_left, self.max_end_right); // write the edges if they exist if let Some(left_node) = &self.left_node { _ = writeln!(f, "{} -> {}", self.x_center, left_node.x_center); From 50021bd3e90d4738c687f63f32d5a54774894400 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Sat, 10 Feb 2024 22:02:21 +0100 Subject: [PATCH 49/52] Implement new features like stranded and nonunique options --- src/main.rs | 155 ++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 107 insertions(+), 48 deletions(-) diff --git a/src/main.rs b/src/main.rs index 9b75ba7..0047b04 100755 --- a/src/main.rs +++ b/src/main.rs @@ -245,8 +245,14 @@ struct Args { // Stranded // TODO: implement stranded mode - #[structopt(long = "stranded")] - _stranded: bool, + #[structopt( + short = "s", + long = "stranded", + help = "Whether the data is from a strand-specific assay. Specify 'yes', 'no', or 'reverse' (default: yes). 'reverse' means 'yes' with reversed strand interpretation", + default_value = "yes", + possible_values = &["yes", "no", "reverse"] + )] + stranded: String, // Quality filter #[structopt( @@ -311,6 +317,15 @@ struct Args { )] delimiter: String, + // non-unique parameter + #[structopt( + long = "nonunique", + default_value = "none", + possible_values = &["none", "all", "fraction","random"], + help = "Whether and how to score reads that are not uniquely aligned or ambiguously assigned to features (choices: none, all, fraction, random; default: none)" + )] + nonunique: String, + // Output file #[structopt( short = "c", @@ -335,24 +350,24 @@ struct Args { output_sam: Option, } -fn prepare_count_hashmap(gtf: &Vec>) -> HashMap { - let mut counts = HashMap::with_capacity(gtf.len()); +fn prepare_count_hashmap(gtf: &Vec>) -> HashMap { + let mut counts: HashMap = HashMap::with_capacity(gtf.len()); // add all features to the map for tree in gtf { if tree.is_none() { continue; } for feature in tree.as_ref().unwrap().all_intervals.iter() { - counts.entry(feature.data.as_ref().unwrap().name.clone()).or_insert(0); + counts.entry(feature.data.as_ref().unwrap().name().to_string()).or_insert(0.0); } } // Add the special keys - counts.insert("__no_feature".to_string(), 0); - counts.insert("__ambiguous".to_string(), 0); - counts.insert("__not_aligned".to_string(), 0); - counts.insert("__too_low_aQual".to_string(), 0); - counts.insert("__alignment_not_unique".to_string(), 0); + counts.insert("__no_feature".to_string(), 0 as f32); + counts.insert("__ambiguous".to_string(), 0 as f32); + counts.insert("__not_aligned".to_string(), 0 as f32); + counts.insert("__too_low_aQual".to_string(), 0 as f32); + counts.insert("__alignment_not_unique".to_string(), 0 as f32); counts } @@ -381,12 +396,12 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa let start = fields.next().unwrap().parse::().unwrap(); let end = fields.next().unwrap().parse::().unwrap(); - + let strand = fields.nth(1).unwrap(); if feature_name != feature_type_filter { line.clear(); continue; } - let attributes = fields.nth(3).unwrap(); + let attributes = fields.nth(1).unwrap(); //eprintln!("attributes: {}", attributes); let name = attributes.split(';') @@ -397,12 +412,8 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa .unwrap_or("") .trim_matches('"'); - let feature = Feature { - name: name.to_string(), - chr: *chr_id, - start: min(start, end), - end: max(start, end), - }; + let feature = Feature::new(name.to_string(), *chr_id, min(start, end), max(start, end), strand.chars().next().unwrap()); + map.entry(*chr_id).or_default().push(Interval::new(start, end, Some(feature))); line.clear(); @@ -437,14 +448,14 @@ fn read_gtf(file_path: &str, feature_type_filter: &str, ref_names_to_id: &HashMa fn should_skip_record( record: &bam::Record, - counts: &mut HashMap, + counts: &mut HashMap, args: &Args, sender: &mpsc::Sender, ) -> bool { // Skip all reads that are not aligned if record.ref_id() < 0 { _ = sender.send(FeatureType::NotAligned); - *counts.entry("__not_aligned".to_string()).or_insert(0) += 1; + *counts.entry("__not_aligned".to_string()).or_insert(0.0) += 1.0; return true; } // Skip all reads that are secondary alignments @@ -460,7 +471,7 @@ fn should_skip_record( // Skip all reads with MAPQ alignment quality lower than the given minimum value if record.mapq() < args.a { _ = sender.send( FeatureType::TooLowaQual); - *counts.entry("__too_low_aQual".to_string()).or_insert(0) += 1; + *counts.entry("__too_low_aQual".to_string()).or_insert(0.0) += 1.0; return true; } // Skip all reads that have an optional field "NH" with value > 1 @@ -469,14 +480,15 @@ fn should_skip_record( _ = sender.send( FeatureType::AlignmentNotUnique); *counts .entry("__alignment_not_unique".to_string()) - .or_insert(0) += 1; + .or_insert(0.0) += 1.0; + // TODO: in nonunique mode "all" we should also increment the features for each alignment (process the read anyways), but we should check what happens if the read is also ambiguous return true; } } false } -fn print_output(counts: HashMap, args: Args, counter: i32) { +fn print_output(counts: HashMap, args: Args, counter: i32) { // Print de HashMap let mut sorted_keys: Vec<_> = counts.keys().collect(); // Sort the keys case-insensitively @@ -485,7 +497,16 @@ fn print_output(counts: HashMap, args: Args, counter: i32) { if key.starts_with("__") { continue; } - println!("{}{}{}", key, args.delimiter, counts[key]); + if args.nonunique != "fraction" { + println!("{}{}{}", key, args.delimiter, counts[key]); + continue; + } + // print the fraction as a float with 1 decimal if not 0 + if counts[key] == 0.0 { + println!("{}{}{}", key, args.delimiter, counts[key]); + continue; + } + println!("{}{}{:.1}", key, args.delimiter, counts[key]); } println!("__no_feature{}{}", args.delimiter, counts["__no_feature"]); println!("__ambiguous{}{}", args.delimiter, counts["__ambiguous"]); @@ -493,11 +514,12 @@ fn print_output(counts: HashMap, args: Args, counter: i32) { println!("__not_aligned{}{}", args.delimiter, counts["__not_aligned"]); println!("__alignment_not_unique{}{}",args.delimiter, counts["__alignment_not_unique"]); + // TODO: check the correctness, since it might depend on nonunique mode if args.counts { println!( "Total number of uniquely mapped reads{}{}", args.delimiter, - counter + counter as f32 - counts["__not_aligned"] - counts["__too_low_aQual"] - counts["__alignment_not_unique"] @@ -507,7 +529,7 @@ fn print_output(counts: HashMap, args: Args, counter: i32) { } } -fn write_counts(counts: HashMap, args: Args, counter: i32) { +fn write_counts(counts: HashMap, args: Args, counter: i32) { let mut sorted_keys: Vec<_> = counts.keys().collect(); // Sort the keys case-insensitively sorted_keys.sort(); @@ -526,7 +548,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { if args.counts { file.write_all(format!("Total number of uniquely mapped reads{}{}\n",args.delimiter, - counter - counts["__not_aligned"] - counts["__too_low_aQual"] - counts["__alignment_not_unique"] - counts["__ambiguous"] - counts["__no_feature"]) + counter as f32 - counts["__not_aligned"] - counts["__too_low_aQual"] - counts["__alignment_not_unique"] - counts["__ambiguous"] - counts["__no_feature"]) .as_bytes(), ) .expect("Unable to write data"); @@ -534,7 +556,7 @@ fn write_counts(counts: HashMap, args: Args, counter: i32) { } -fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { +fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut HashMap, args: &Args, gtf: Vec>, sender: mpsc::Sender) { let processing_function = match args._m.as_str() { "intersection-strict" => process_intersection_strict_read, "intersection-nonempty" => process_intersection_nonempty_read, @@ -589,7 +611,7 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H eprintln!("start_pos: {}, end_pos: {}, cig:{:?}", start_pos, partial_end_pos, cig); } */ - processing_function(features, start_pos, partial_end_pos, &mut overlapping_features); + processing_function(features, start_pos, partial_end_pos, record.flag().is_reverse_strand(), &mut overlapping_features, args); /* if record.name() == "SRR5724993.43083906".to_string().as_bytes(){ eprintln!("overlapping_features: {:?}", overlapping_features); } */ @@ -604,21 +626,40 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H match feature_name_len { 0 => { // if there are no unique feature names, we have no feature - *counts.entry("__no_feature".to_string()).or_insert(0) += 1; + *counts.entry("__no_feature".to_string()).or_insert(0.0) += 1.0; _ = sender.send(FeatureType::NoFeature); }, 1 => { // if there is only one unique feature name, we have a non-ambiguous read let feature_name = unique_feature_names.first().unwrap(); - *counts.entry(feature_name.clone()).or_insert(0) += 1; + *counts.entry(feature_name.clone()).or_insert(0.0) += 1.0; _ = sender.send(FeatureType::Name(feature_name.clone())); }, _ => { // if there are multiple unique feature names, we have an ambiguous read - *counts.entry("__ambiguous".to_string()).or_insert(0) += 1; - // we also increment each feature name by 1 - for feature_name in unique_feature_names.clone() { - *counts.entry(feature_name.clone()).or_insert(0) += 1; + *counts.entry("__ambiguous".to_string()).or_insert(0.0) += 1.0; + match args.nonunique.as_str() { + "all" => { + // we also increment each feature name by 1 + for feature_name in unique_feature_names.clone() { + *counts.entry(feature_name.clone()).or_insert(0.0) += 1.0; + } + }, + "fraction" => { + // we increment each feature name by 1 divided by the amount of unique feature names + let fractional_count = 1.0 / feature_name_len as f32; + for feature_name in unique_feature_names.clone() { + *counts.entry(feature_name.clone()).or_insert(0.0) += fractional_count; + } + }, + "random" => { + // we increment one of the feature names by 1 + let random_index = rand::random::() % feature_name_len; + let feature_name = unique_feature_names[random_index].clone(); + *counts.entry(feature_name).or_insert(0.0) += 1.0; + }, + _ => {// do nothing + }, } unique_feature_names.sort(); _ = sender.send(FeatureType::Ambiguous(unique_feature_names.join("+"))); @@ -627,7 +668,7 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H } else { // No reference found for this read // TODO: check if we should add this to __no_feature or we should throw an error - *counts.entry("__no_feature".to_string()).or_insert(0) +=1; + *counts.entry("__no_feature".to_string()).or_insert(0.0) += 1.0; _ = sender.send(FeatureType::NoFeature); } } @@ -635,27 +676,45 @@ fn count_reads(reads_reader: &mut ReadsReader, counter: &mut i32, counts: &mut H eprintln!("{} records processed.", counter); } -fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, overlapping_features: &mut Vec) { +fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, is_reverse_strand: bool, overlapping_features: &mut Vec, args: &Args) { let new_overlap = features.overlap(start_pos, end_pos); + let strand = if is_reverse_strand { '-' } else { '+' }; // add all overlapping features to the list for overlap in new_overlap { let feature = overlap.data.as_ref().unwrap(); - overlapping_features.push(feature.clone()); + match args.stranded.as_str() { + "yes" => { + //eprintln!("feature: {:?}", feature); + if feature.strand() == strand { + overlapping_features.push(feature.clone()); + } + }, + "reverse" => { + if feature.strand() != strand { + overlapping_features.push(feature.clone()); + } + }, + "no" => { + overlapping_features.push(feature.clone()); + }, + _ => { + panic!("Invalid strandedness"); + } + } } } -fn filter_ambiguity_union( - overlapping_features: &[Feature], -) -> Vec { - let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name.clone()).filter(|x| !x.is_empty()).collect(); - unique_feature_names.into_iter().collect() - +fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _strand: bool, _overlapping_features: &mut Vec, _args: &Args) { + todo!("process_partial_read for intersection-nonempty"); } -fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _overlapping_features: &mut Vec) { - todo!("process_partial_read for intersection-nonempty"); +fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _strand: bool, _overlapping_features: &mut Vec, _args: &Args) { + todo!("process_partial_read for intersection-strict"); } -fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _overlapping_features: &mut Vec) { - todo!("process_partial_read for intersection-strict"); +fn filter_ambiguity_union( + overlapping_features: &[Feature], +) -> Vec { + let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name().to_string().clone()).filter(|x| !x.is_empty()).collect(); + unique_feature_names.into_iter().collect() } \ No newline at end of file From 11c7b2aa837422143eff68d5fddb330cd9d22e3e Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 12 Feb 2024 05:46:45 +0100 Subject: [PATCH 50/52] Update long option names in Args struct --- src/main.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main.rs b/src/main.rs index 0047b04..54d7975 100755 --- a/src/main.rs +++ b/src/main.rs @@ -257,7 +257,7 @@ struct Args { // Quality filter #[structopt( short = "a", - long = "amount", + long = "minaqual", default_value = "10", help = "Skip all reads with MAPQ alignment quality lower than the given minimum value (default: 10). MAPQ is the 5th column of a SAM/BAM file and its usage depends on the software used to map the reads." )] @@ -276,7 +276,7 @@ struct Args { // TODO: implement actual logic for this option #[structopt( short = "i", - long = "id", + long = "idattr", default_value = "gene_name", help = "GTF attribute to be used as feature ID (default, suitable for Ensembl GTF files: gene_id). All feature of the right type (see -t option) within the same GTF attribute will be added together. The typical way of using this option is to count all exonic reads from each gene and add the exons but other uses are possible @@ -344,7 +344,7 @@ struct Args { #[structopt( short = "o", - long = "output_sam", + long = "samout", help = "Create a SAM file with the reads and their features." )] output_sam: Option, From f10899e032a94f95e74ab398c637814fd0c87e47 Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Mon, 12 Feb 2024 20:05:21 +0100 Subject: [PATCH 51/52] Add contains() method to IntervalTree and implement first version of intersection_strict --- src/intervaltree.rs | 7 +++++++ src/main.rs | 39 ++++++++++++++++++++++++--------------- 2 files changed, 31 insertions(+), 15 deletions(-) diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 4b016a2..8d26259 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -299,4 +299,11 @@ impl IntervalTree { result } + pub fn contains(&self, start: i32, end: i32) -> Vec<&Interval> { + let mut result = self.overlap(start, end); + // TODO: merge overlapping intervals with same name into one interval + result.retain(|x| x.start <= start && x.end >= end); + result + } + } \ No newline at end of file diff --git a/src/main.rs b/src/main.rs index 54d7975..c5d9bbb 100755 --- a/src/main.rs +++ b/src/main.rs @@ -680,6 +680,30 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, is_ let new_overlap = features.overlap(start_pos, end_pos); let strand = if is_reverse_strand { '-' } else { '+' }; // add all overlapping features to the list + add_stranded_features(new_overlap, strand, overlapping_features, args); + +} + +fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _strand: bool, _overlapping_features: &mut Vec, _args: &Args) { + todo!("process_partial_read for intersection-nonempty"); +} + +fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, strand: bool, overlapping_features: &mut Vec, args: &Args) { + //todo!("process_partial_read for intersection-strict"); + let new_contained = features.contains(start_pos, end_pos); + let strand = if strand { '-' } else { '+' }; + // add all contained features to the list + add_stranded_features(new_contained, strand, overlapping_features, args); +} + +fn filter_ambiguity_union( + overlapping_features: &[Feature], +) -> Vec { + let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name().to_string().clone()).filter(|x| !x.is_empty()).collect(); + unique_feature_names.into_iter().collect() +} + +fn add_stranded_features(new_overlap: Vec<&Interval>, strand: char, overlapping_features: &mut Vec, args: &Args) { for overlap in new_overlap { let feature = overlap.data.as_ref().unwrap(); match args.stranded.as_str() { @@ -702,19 +726,4 @@ fn process_union_read(features: &IntervalTree, start_pos: i32, end_pos: i32, is_ } } } -} - -fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _strand: bool, _overlapping_features: &mut Vec, _args: &Args) { - todo!("process_partial_read for intersection-nonempty"); -} - -fn process_intersection_strict_read(_features: &IntervalTree, _start_pos: i32, _end_pos: i32, _strand: bool, _overlapping_features: &mut Vec, _args: &Args) { - todo!("process_partial_read for intersection-strict"); -} - -fn filter_ambiguity_union( - overlapping_features: &[Feature], -) -> Vec { - let unique_feature_names: HashSet = overlapping_features.iter().map(|x| x.name().to_string().clone()).filter(|x| !x.is_empty()).collect(); - unique_feature_names.into_iter().collect() } \ No newline at end of file From c7bc91979cbac31368f1e6b96c6b0ca5465e0a3d Mon Sep 17 00:00:00 2001 From: CedricHermansBIT Date: Thu, 15 Feb 2024 14:09:03 +0100 Subject: [PATCH 52/52] Merge features in tree, so we have 1: fewer branches, 2: parity with the original htseq-count --- src/feature.rs | 4 ++++ src/interval.rs | 12 ++++++++++-- src/intervaltree.rs | 37 +++++++++++++++++++++++++++++++++++-- src/main.rs | 14 +++++++------- 4 files changed, 56 insertions(+), 11 deletions(-) diff --git a/src/feature.rs b/src/feature.rs index 65e3885..f29a95c 100644 --- a/src/feature.rs +++ b/src/feature.rs @@ -41,4 +41,8 @@ impl Feature { pub fn strand(&self) -> char { self.strand } + + pub fn set_end(&mut self, end: i32) { + self.end = end; + } } \ No newline at end of file diff --git a/src/interval.rs b/src/interval.rs index 2b362d3..7103873 100644 --- a/src/interval.rs +++ b/src/interval.rs @@ -107,6 +107,16 @@ impl Interval { self.start < end && self.end-1 > start } + // as_ref() returns a reference to the Option's value + pub fn name(&self) -> Option<&str> { + self.data.as_ref().map(|f| f.name()) + } + + pub fn set_end(&mut self, end: i32) { + self.end = end; + self.data.as_mut().map(|f| f.set_end(end)); + } + } impl PartialOrd for Interval { @@ -139,5 +149,3 @@ impl std::fmt::Display for Interval { } } } - - diff --git a/src/intervaltree.rs b/src/intervaltree.rs index 8d26259..0560792 100644 --- a/src/intervaltree.rs +++ b/src/intervaltree.rs @@ -22,6 +22,39 @@ impl IntervalTree { for interval in intervals { unique_intervals.insert(interval); } + + // merge overlapping intervals with same name + use std::collections::HashMap; + + // Create a HashMap where the keys are the names of the intervals and the values are vectors of intervals with that name. + let mut grouped_intervals: HashMap> = HashMap::new(); + for interval in &unique_intervals { + grouped_intervals.entry(interval.name().unwrap().to_string()).or_insert(Vec::new()).push(interval.clone()); + } + + // For each name in the HashMap, sort the intervals by their start position and then merge the overlapping intervals. + for intervals in grouped_intervals.values_mut() { + intervals.sort_by(|a, b| a.start.cmp(&b.start)); + let mut i = 0; + while i < intervals.len() - 1 { + if intervals[i].end >= intervals[i+1].start && intervals[i+1].end >= intervals[i].end { + intervals[i].end = intervals[i+1].end; + intervals.remove(i+1); + } else { + i += 1; + } + } + } + + // Create a new HashSet of intervals from the merged intervals. + let mut unique_intervals: HashSet = HashSet::new(); + for intervals in grouped_intervals.values() { + for interval in intervals { + unique_intervals.insert(interval.clone()); + } + } + + // convert to vector //let unique_intervals: Vec = unique_intervals.into_iter().collect(); //eprintln!("filtered intervals"); @@ -91,6 +124,7 @@ impl IntervalTree { } } + pub fn add(&mut self, interval: Interval) { if interval.is_null() { panic!("IntervalTree: Null Interval objects are not allowed in IntervalTree"); @@ -300,8 +334,7 @@ impl IntervalTree { } pub fn contains(&self, start: i32, end: i32) -> Vec<&Interval> { - let mut result = self.overlap(start, end); - // TODO: merge overlapping intervals with same name into one interval + let mut result: Vec<&Interval> = self.overlap(start, end); result.retain(|x| x.start <= start && x.end >= end); result } diff --git a/src/main.rs b/src/main.rs index c5d9bbb..526e502 100755 --- a/src/main.rs +++ b/src/main.rs @@ -244,7 +244,6 @@ struct Args { _m: String, // Stranded - // TODO: implement stranded mode #[structopt( short = "s", long = "stranded", @@ -363,17 +362,17 @@ fn prepare_count_hashmap(gtf: &Vec>) -> HashMap) -> Vec> { let mut map: HashMap> = HashMap::new(); - let file = File::open(file_path).expect("Kan het bestand niet openen"); + let file = File::open(file_path).expect("Could not open this file"); let mut reader = BufReader::new(file); let mut counter = 0; let mut line = String::new(); @@ -691,6 +690,7 @@ fn process_intersection_nonempty_read(_features: &IntervalTree, _start_pos: i32, fn process_intersection_strict_read(features: &IntervalTree, start_pos: i32, end_pos: i32, strand: bool, overlapping_features: &mut Vec, args: &Args) { //todo!("process_partial_read for intersection-strict"); let new_contained = features.contains(start_pos, end_pos); + // change new_contained to a Vec<&Interval> let strand = if strand { '-' } else { '+' }; // add all contained features to the list add_stranded_features(new_contained, strand, overlapping_features, args);