From 6dacd9d2805d0899a59329fdc4e43dfacdf93044 Mon Sep 17 00:00:00 2001 From: tcofoegbu Date: Thu, 21 Jan 2016 14:59:40 +0000 Subject: [PATCH] JAL-1479 JAL-1979 updated the modified-aminoacid triplet code dictionary in Jalview using data from SCOP/PDB provided by Fabio --- src/jalview/schemes/ResidueProperties.java | 1309 ++++++++++++++++++++++- src/jalview/ws/sifts/SiftsClient.java | 3 +- test/jalview/schemes/ResiduePropertiesTest.java | 1301 ++++++++++++++++++++++ 3 files changed, 2610 insertions(+), 3 deletions(-) diff --git a/src/jalview/schemes/ResidueProperties.java b/src/jalview/schemes/ResidueProperties.java index de99987..ad68b8a 100755 --- a/src/jalview/schemes/ResidueProperties.java +++ b/src/jalview/schemes/ResidueProperties.java @@ -245,13 +245,14 @@ public class ResidueProperties aa3Hash.put("VAL", new Integer(19)); // IUB Nomenclature for ambiguous peptides aa3Hash.put("ASX", new Integer(20)); // "B"; - aa3Hash.put("GLX", new Integer(21)); // X + aa3Hash.put("GLX", new Integer(21)); // Z aa3Hash.put("XAA", new Integer(22)); // X unknown aa3Hash.put("-", new Integer(23)); aa3Hash.put("*", new Integer(23)); aa3Hash.put(".", new Integer(23)); aa3Hash.put(" ", new Integer(23)); aa3Hash.put("Gap", new Integer(23)); + aa3Hash.put("UR3", new Integer(24)); } static @@ -300,7 +301,7 @@ public class ResidueProperties public static final String[] aa = { "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V", "B", - "Z", "X", "_", "*", ".", " " }; + "Z", "X", "_", "*", ".", " ", "U" }; public static final Color midBlue = new Color(100, 100, 255); @@ -1695,6 +1696,1310 @@ public class ResidueProperties // modifications.put("5HP", "GLU"); // Pyroglutamic acid; 5-hydroxyproline // modifications.put("PCA", "GLU"); // Pyroglutamic acid // modifications.put("LYZ", "LYS"); // 5-hydroxylysine + + // Additional protein alphabets used in the SCOP database and PDB files + // source: + // https://github.com/biopython/biopython/blob/master/Bio/Data/SCOPData.py + modifications.put("00C", "CYS"); + modifications.put("01W", "XAA"); + modifications.put("02K", "ALA"); + modifications.put("03Y", "CYS"); + modifications.put("07O", "CYS"); + modifications.put("08P", "CYS"); + modifications.put("0A0", "ASP"); + modifications.put("0A1", "TYR"); + modifications.put("0A2", "LYS"); + modifications.put("0A8", "CYS"); + modifications.put("0AA", "VAL"); + modifications.put("0AB", "VAL"); + modifications.put("0AC", "GLY"); + modifications.put("0AD", "GLY"); + modifications.put("0AF", "TRP"); + modifications.put("0AG", "LEU"); + modifications.put("0AH", "SER"); + modifications.put("0AK", "ASP"); + modifications.put("0AM", "ALA"); + modifications.put("0AP", "CYS"); + modifications.put("0AU", "UR3"); + modifications.put("0AV", "ALA"); + modifications.put("0AZ", "PRO"); + modifications.put("0BN", "PHE"); + modifications.put("0C ", "CYS"); + modifications.put("0CS", "ALA"); + modifications.put("0DC", "CYS"); + modifications.put("0DG", "GLY"); + modifications.put("0DT", "THR"); + modifications.put("0FL", "ALA"); + modifications.put("0G ", "GLY"); + modifications.put("0NC", "ALA"); + modifications.put("0SP", "ALA"); + modifications.put("0U ", "UR3"); + modifications.put("0YG", "YG"); + modifications.put("10C", "CYS"); + modifications.put("125", "UR3"); + modifications.put("126", "UR3"); + modifications.put("127", "UR3"); + modifications.put("128", "ASN"); + modifications.put("12A", "ALA"); + modifications.put("143", "CYS"); + modifications.put("175", "ASG"); + modifications.put("193", "XAA"); + modifications.put("1AP", "ALA"); + modifications.put("1MA", "ALA"); + modifications.put("1MG", "GLY"); + modifications.put("1PA", "PHE"); + modifications.put("1PI", "ALA"); + modifications.put("1PR", "ASN"); + modifications.put("1SC", "CYS"); + modifications.put("1TQ", "TRP"); + modifications.put("1TY", "TYR"); + modifications.put("1X6", "SER"); + modifications.put("200", "PHE"); + modifications.put("23F", "PHE"); + modifications.put("23S", "XAA"); + modifications.put("26B", "THR"); + modifications.put("2AD", "XAA"); + modifications.put("2AG", "ALA"); + modifications.put("2AO", "XAA"); + modifications.put("2AR", "ALA"); + modifications.put("2AS", "XAA"); + modifications.put("2AT", "THR"); + modifications.put("2AU", "UR3"); + modifications.put("2BD", "ILE"); + modifications.put("2BT", "THR"); + modifications.put("2BU", "ALA"); + modifications.put("2CO", "CYS"); + modifications.put("2DA", "ALA"); + modifications.put("2DF", "ASN"); + modifications.put("2DM", "ASN"); + modifications.put("2DO", "XAA"); + modifications.put("2DT", "THR"); + modifications.put("2EG", "GLY"); + modifications.put("2FE", "ASN"); + modifications.put("2FI", "ASN"); + modifications.put("2FM", "MET"); + modifications.put("2GT", "THR"); + modifications.put("2HF", "HIS"); + modifications.put("2LU", "LEU"); + modifications.put("2MA", "ALA"); + modifications.put("2MG", "GLY"); + modifications.put("2ML", "LEU"); + modifications.put("2MR", "ARG"); + modifications.put("2MT", "PRO"); + modifications.put("2MU", "UR3"); + modifications.put("2NT", "THR"); + modifications.put("2OM", "UR3"); + modifications.put("2OT", "THR"); + modifications.put("2PI", "XAA"); + modifications.put("2PR", "GLY"); + modifications.put("2SA", "ASN"); + modifications.put("2SI", "XAA"); + modifications.put("2ST", "THR"); + modifications.put("2TL", "THR"); + modifications.put("2TY", "TYR"); + modifications.put("2VA", "VAL"); + modifications.put("2XA", "CYS"); + modifications.put("32S", "XAA"); + modifications.put("32T", "XAA"); + modifications.put("3AH", "HIS"); + modifications.put("3AR", "XAA"); + modifications.put("3CF", "PHE"); + modifications.put("3DA", "ALA"); + modifications.put("3DR", "ASN"); + modifications.put("3GA", "ALA"); + modifications.put("3MD", "ASP"); + modifications.put("3ME", "UR3"); + modifications.put("3NF", "TYR"); + modifications.put("3QN", "LYS"); + modifications.put("3TY", "XAA"); + modifications.put("3XH", "GLY"); + modifications.put("4AC", "ASN"); + modifications.put("4BF", "TYR"); + modifications.put("4CF", "PHE"); + modifications.put("4CY", "MET"); + modifications.put("4DP", "TRP"); + modifications.put("4F3", "GYG"); + modifications.put("4FB", "PRO"); + modifications.put("4FW", "TRP"); + modifications.put("4HT", "TRP"); + modifications.put("4IN", "TRP"); + modifications.put("4MF", "ASN"); + modifications.put("4MM", "XAA"); + modifications.put("4OC", "CYS"); + modifications.put("4PC", "CYS"); + modifications.put("4PD", "CYS"); + modifications.put("4PE", "CYS"); + modifications.put("4PH", "PHE"); + modifications.put("4SC", "CYS"); + modifications.put("4SU", "UR3"); + modifications.put("4TA", "ASN"); + modifications.put("4U7", "ALA"); + modifications.put("56A", "HIS"); + modifications.put("5AA", "ALA"); + modifications.put("5AB", "ALA"); + modifications.put("5AT", "THR"); + modifications.put("5BU", "UR3"); + modifications.put("5CG", "GLY"); + modifications.put("5CM", "CYS"); + modifications.put("5CS", "CYS"); + modifications.put("5FA", "ALA"); + modifications.put("5FC", "CYS"); + modifications.put("5FU", "UR3"); + modifications.put("5HP", "GLU"); + modifications.put("5HT", "THR"); + modifications.put("5HU", "UR3"); + modifications.put("5IC", "CYS"); + modifications.put("5IT", "THR"); + modifications.put("5IU", "UR3"); + modifications.put("5MC", "CYS"); + modifications.put("5MD", "ASN"); + modifications.put("5MU", "UR3"); + modifications.put("5NC", "CYS"); + modifications.put("5PC", "CYS"); + modifications.put("5PY", "THR"); + modifications.put("5SE", "UR3"); + modifications.put("5ZA", "TWG"); + modifications.put("64T", "THR"); + modifications.put("6CL", "LYS"); + modifications.put("6CT", "THR"); + modifications.put("6CW", "TRP"); + modifications.put("6HA", "ALA"); + modifications.put("6HC", "CYS"); + modifications.put("6HG", "GLY"); + modifications.put("6HN", "LYS"); + modifications.put("6HT", "THR"); + modifications.put("6IA", "ALA"); + modifications.put("6MA", "ALA"); + modifications.put("6MC", "ALA"); + modifications.put("6MI", "ASN"); + modifications.put("6MT", "ALA"); + modifications.put("6MZ", "ASN"); + modifications.put("6OG", "GLY"); + modifications.put("70U", "UR3"); + modifications.put("7DA", "ALA"); + modifications.put("7GU", "GLY"); + modifications.put("7JA", "ILE"); + modifications.put("7MG", "GLY"); + modifications.put("8AN", "ALA"); + modifications.put("8FG", "GLY"); + modifications.put("8MG", "GLY"); + modifications.put("8OG", "GLY"); + modifications.put("9NE", "GLU"); + modifications.put("9NF", "PHE"); + modifications.put("9NR", "ARG"); + modifications.put("9NV", "VAL"); + modifications.put("A ", "ALA"); + modifications.put("A1P", "ASN"); + modifications.put("A23", "ALA"); + modifications.put("A2L", "ALA"); + modifications.put("A2M", "ALA"); + modifications.put("A34", "ALA"); + modifications.put("A35", "ALA"); + modifications.put("A38", "ALA"); + modifications.put("A39", "ALA"); + modifications.put("A3A", "ALA"); + modifications.put("A3P", "ALA"); + modifications.put("A40", "ALA"); + modifications.put("A43", "ALA"); + modifications.put("A44", "ALA"); + modifications.put("A47", "ALA"); + modifications.put("A5L", "ALA"); + modifications.put("A5M", "CYS"); + modifications.put("A5N", "ASN"); + modifications.put("A5O", "ALA"); + modifications.put("A66", "XAA"); + modifications.put("AA3", "ALA"); + modifications.put("AA4", "ALA"); + modifications.put("AAR", "ARG"); + modifications.put("AB7", "XAA"); + modifications.put("ABA", "ALA"); + modifications.put("ABR", "ALA"); + modifications.put("ABS", "ALA"); + modifications.put("ABT", "ASN"); + modifications.put("ACB", "ASP"); + modifications.put("ACL", "ARG"); + modifications.put("AD2", "ALA"); + modifications.put("ADD", "XAA"); + modifications.put("ADX", "ASN"); + modifications.put("AEA", "XAA"); + modifications.put("AEI", "ASP"); + modifications.put("AET", "ALA"); + modifications.put("AFA", "ASN"); + modifications.put("AFF", "ASN"); + modifications.put("AFG", "GLY"); + modifications.put("AGM", "ARG"); + modifications.put("AGT", "CYS"); + modifications.put("AHB", "ASN"); + modifications.put("AHH", "XAA"); + modifications.put("AHO", "ALA"); + modifications.put("AHP", "ALA"); + modifications.put("AHS", "XAA"); + modifications.put("AHT", "XAA"); + modifications.put("AIB", "ALA"); + modifications.put("AKL", "ASP"); + modifications.put("AKZ", "ASP"); + modifications.put("ALA", "ALA"); + modifications.put("ALC", "ALA"); + modifications.put("ALM", "ALA"); + modifications.put("ALN", "ALA"); + modifications.put("ALO", "THR"); + modifications.put("ALQ", "XAA"); + modifications.put("ALS", "ALA"); + modifications.put("ALT", "ALA"); + modifications.put("ALV", "ALA"); + modifications.put("ALY", "LYS"); + modifications.put("AN8", "ALA"); + modifications.put("AP7", "ALA"); + modifications.put("APE", "XAA"); + modifications.put("APH", "ALA"); + modifications.put("API", "LYS"); + modifications.put("APK", "LYS"); + modifications.put("APM", "XAA"); + modifications.put("APP", "XAA"); + modifications.put("AR2", "ARG"); + modifications.put("AR4", "GLU"); + modifications.put("AR7", "ARG"); + modifications.put("ARG", "ARG"); + modifications.put("ARM", "ARG"); + modifications.put("ARO", "ARG"); + modifications.put("ARV", "XAA"); + modifications.put("AS ", "ALA"); + modifications.put("AS2", "ASP"); + modifications.put("AS9", "XAA"); + modifications.put("ASA", "ASP"); + modifications.put("ASB", "ASP"); + modifications.put("ASI", "ASP"); + modifications.put("ASK", "ASP"); + modifications.put("ASL", "ASP"); + modifications.put("ASM", "XAA"); + modifications.put("ASN", "ASN"); + modifications.put("ASP", "ASP"); + modifications.put("ASQ", "ASP"); + modifications.put("ASU", "ASN"); + modifications.put("ASX", "ASX"); + modifications.put("ATD", "THR"); + modifications.put("ATL", "THR"); + modifications.put("ATM", "THR"); + modifications.put("AVC", "ALA"); + modifications.put("AVN", "XAA"); + modifications.put("AYA", "ALA"); + modifications.put("AYG", "AYG"); + modifications.put("AZK", "LYS"); + modifications.put("AZS", "SER"); + modifications.put("AZY", "TYR"); + modifications.put("B1F", "PHE"); + modifications.put("B1P", "ASN"); + modifications.put("B2A", "ALA"); + modifications.put("B2F", "PHE"); + modifications.put("B2I", "ILE"); + modifications.put("B2V", "VAL"); + modifications.put("B3A", "ALA"); + modifications.put("B3D", "ASP"); + modifications.put("B3E", "GLU"); + modifications.put("B3K", "LYS"); + modifications.put("B3L", "XAA"); + modifications.put("B3M", "XAA"); + modifications.put("B3Q", "XAA"); + modifications.put("B3S", "SER"); + modifications.put("B3T", "XAA"); + modifications.put("B3U", "HIS"); + modifications.put("B3X", "ASN"); + modifications.put("B3Y", "TYR"); + modifications.put("BB6", "CYS"); + modifications.put("BB7", "CYS"); + modifications.put("BB8", "PHE"); + modifications.put("BB9", "CYS"); + modifications.put("BBC", "CYS"); + modifications.put("BCS", "CYS"); + modifications.put("BE2", "XAA"); + modifications.put("BFD", "ASP"); + modifications.put("BG1", "SER"); + modifications.put("BGM", "GLY"); + modifications.put("BH2", "ASP"); + modifications.put("BHD", "ASP"); + modifications.put("BIF", "PHE"); + modifications.put("BIL", "XAA"); + modifications.put("BIU", "ILE"); + modifications.put("BJH", "XAA"); + modifications.put("BLE", "LEU"); + modifications.put("BLY", "LYS"); + modifications.put("BMP", "ASN"); + modifications.put("BMT", "THR"); + modifications.put("BNN", "PHE"); + modifications.put("BNO", "XAA"); + modifications.put("BOE", "THR"); + modifications.put("BOR", "ARG"); + modifications.put("BPE", "CYS"); + modifications.put("BRU", "UR3"); + modifications.put("BSE", "SER"); + modifications.put("BT5", "ASN"); + modifications.put("BTA", "LEU"); + modifications.put("BTC", "CYS"); + modifications.put("BTR", "TRP"); + modifications.put("BUC", "CYS"); + modifications.put("BUG", "VAL"); + modifications.put("BVP", "UR3"); + modifications.put("BZG", "ASN"); + modifications.put("C ", "CYS"); + modifications.put("C12", "TYG"); + modifications.put("C1X", "LYS"); + modifications.put("C25", "CYS"); + modifications.put("C2L", "CYS"); + modifications.put("C2S", "CYS"); + modifications.put("C31", "CYS"); + modifications.put("C32", "CYS"); + modifications.put("C34", "CYS"); + modifications.put("C36", "CYS"); + modifications.put("C37", "CYS"); + modifications.put("C38", "CYS"); + modifications.put("C3Y", "CYS"); + modifications.put("C42", "CYS"); + modifications.put("C43", "CYS"); + modifications.put("C45", "CYS"); + modifications.put("C46", "CYS"); + modifications.put("C49", "CYS"); + modifications.put("C4R", "CYS"); + modifications.put("C4S", "CYS"); + modifications.put("C5C", "CYS"); + modifications.put("C66", "XAA"); + modifications.put("C6C", "CYS"); + modifications.put("C99", "TFG"); + modifications.put("CAF", "CYS"); + modifications.put("CAL", "XAA"); + modifications.put("CAR", "CYS"); + modifications.put("CAS", "CYS"); + modifications.put("CAV", "XAA"); + modifications.put("CAY", "CYS"); + modifications.put("CB2", "CYS"); + modifications.put("CBR", "CYS"); + modifications.put("CBV", "CYS"); + modifications.put("CCC", "CYS"); + modifications.put("CCL", "LYS"); + modifications.put("CCS", "CYS"); + modifications.put("CCY", "CYG"); + modifications.put("CDE", "XAA"); + modifications.put("CDV", "XAA"); + modifications.put("CDW", "CYS"); + modifications.put("CEA", "CYS"); + modifications.put("CFL", "CYS"); + modifications.put("CFY", "FCYG"); // check + modifications.put("CG1", "GLY"); + modifications.put("CGA", "GLU"); + modifications.put("CGU", "GLU"); + modifications.put("CH ", "CYS"); + modifications.put("CH6", "MYG"); + modifications.put("CH7", "KYG"); + modifications.put("CHF", "XAA"); + modifications.put("CHG", "XAA"); + modifications.put("CHP", "GLY"); + modifications.put("CHS", "XAA"); + modifications.put("CIR", "ARG"); + modifications.put("CJO", "GYG"); + modifications.put("CLE", "LEU"); + modifications.put("CLG", "LYS"); + modifications.put("CLH", "LYS"); + modifications.put("CLV", "AFG"); + modifications.put("CM0", "ASN"); + modifications.put("CME", "CYS"); + modifications.put("CMH", "CYS"); + modifications.put("CML", "CYS"); + modifications.put("CMR", "CYS"); + modifications.put("CMT", "CYS"); + modifications.put("CNU", "UR3"); + modifications.put("CP1", "CYS"); + modifications.put("CPC", "XAA"); + modifications.put("CPI", "XAA"); + modifications.put("CQR", "GYG"); + modifications.put("CR0", "TLG"); + modifications.put("CR2", "GYG"); + modifications.put("CR5", "GLY"); + modifications.put("CR7", "KYG"); + modifications.put("CR8", "HYG"); + modifications.put("CRF", "TWG"); + modifications.put("CRG", "THG"); + modifications.put("CRK", "MYG"); + modifications.put("CRO", "GYG"); + modifications.put("CRQ", "QYG"); + modifications.put("CRU", "EYG"); + modifications.put("CRW", "ASG"); + modifications.put("CRX", "ASG"); + modifications.put("CS0", "CYS"); + modifications.put("CS1", "CYS"); + modifications.put("CS3", "CYS"); + modifications.put("CS4", "CYS"); + modifications.put("CS8", "ASN"); + modifications.put("CSA", "CYS"); + modifications.put("CSB", "CYS"); + modifications.put("CSD", "CYS"); + modifications.put("CSE", "CYS"); + modifications.put("CSF", "CYS"); + modifications.put("CSH", "SHG"); + modifications.put("CSI", "GLY"); + modifications.put("CSJ", "CYS"); + modifications.put("CSL", "CYS"); + modifications.put("CSO", "CYS"); + modifications.put("CSP", "CYS"); + modifications.put("CSR", "CYS"); + modifications.put("CSS", "CYS"); + modifications.put("CSU", "CYS"); + modifications.put("CSW", "CYS"); + modifications.put("CSX", "CYS"); + modifications.put("CSY", "SYG"); + modifications.put("CSZ", "CYS"); + modifications.put("CTE", "TRP"); + modifications.put("CTG", "THR"); + modifications.put("CTH", "THR"); + modifications.put("CUC", "XAA"); + modifications.put("CWR", "SER"); + modifications.put("CXM", "MET"); + modifications.put("CY0", "CYS"); + modifications.put("CY1", "CYS"); + modifications.put("CY3", "CYS"); + modifications.put("CY4", "CYS"); + modifications.put("CYA", "CYS"); + modifications.put("CYD", "CYS"); + modifications.put("CYF", "CYS"); + modifications.put("CYG", "CYS"); + modifications.put("CYJ", "XAA"); + modifications.put("CYM", "CYS"); + modifications.put("CYQ", "CYS"); + modifications.put("CYR", "CYS"); + modifications.put("CYS", "CYS"); + modifications.put("CZ2", "CYS"); + modifications.put("CZO", "GYG"); + modifications.put("CZZ", "CYS"); + modifications.put("D11", "THR"); + modifications.put("D1P", "ASN"); + modifications.put("D3 ", "ASN"); + modifications.put("D33", "ASN"); + modifications.put("D3P", "GLY"); + modifications.put("D3T", "THR"); + modifications.put("D4M", "THR"); + modifications.put("D4P", "XAA"); + modifications.put("DA ", "ALA"); + modifications.put("DA2", "XAA"); + modifications.put("DAB", "ALA"); + modifications.put("DAH", "PHE"); + modifications.put("DAL", "ALA"); + modifications.put("DAR", "ARG"); + modifications.put("DAS", "ASP"); + modifications.put("DBB", "THR"); + modifications.put("DBM", "ASN"); + modifications.put("DBS", "SER"); + modifications.put("DBU", "THR"); + modifications.put("DBY", "TYR"); + modifications.put("DBZ", "ALA"); + modifications.put("DC ", "CYS"); + modifications.put("DC2", "CYS"); + modifications.put("DCG", "GLY"); + modifications.put("DCI", "XAA"); + modifications.put("DCL", "XAA"); + modifications.put("DCT", "CYS"); + modifications.put("DCY", "CYS"); + modifications.put("DDE", "HIS"); + modifications.put("DDG", "GLY"); + modifications.put("DDN", "UR3"); + modifications.put("DDX", "ASN"); + modifications.put("DFC", "CYS"); + modifications.put("DFG", "GLY"); + modifications.put("DFI", "XAA"); + modifications.put("DFO", "XAA"); + modifications.put("DFT", "ASN"); + modifications.put("DG ", "GLY"); + modifications.put("DGH", "GLY"); + modifications.put("DGI", "GLY"); + modifications.put("DGL", "GLU"); + modifications.put("DGN", "GLN"); + modifications.put("DHA", "SER"); + modifications.put("DHI", "HIS"); + modifications.put("DHL", "XAA"); + modifications.put("DHN", "VAL"); + modifications.put("DHP", "XAA"); + modifications.put("DHU", "UR3"); + modifications.put("DHV", "VAL"); + modifications.put("DI ", "ILE"); + modifications.put("DIL", "ILE"); + modifications.put("DIR", "ARG"); + modifications.put("DIV", "VAL"); + modifications.put("DLE", "LEU"); + modifications.put("DLS", "LYS"); + modifications.put("DLY", "LYS"); + modifications.put("DM0", "LYS"); + modifications.put("DMH", "ASN"); + modifications.put("DMK", "ASP"); + modifications.put("DMT", "XAA"); + modifications.put("DN ", "ASN"); + modifications.put("DNE", "LEU"); + modifications.put("DNG", "LEU"); + modifications.put("DNL", "LYS"); + modifications.put("DNM", "LEU"); + modifications.put("DNP", "ALA"); + modifications.put("DNR", "CYS"); + modifications.put("DNS", "LYS"); + modifications.put("DOA", "XAA"); + modifications.put("DOC", "CYS"); + modifications.put("DOH", "ASP"); + modifications.put("DON", "LEU"); + modifications.put("DPB", "THR"); + modifications.put("DPH", "PHE"); + modifications.put("DPL", "PRO"); + modifications.put("DPP", "ALA"); + modifications.put("DPQ", "TYR"); + modifications.put("DPR", "PRO"); + modifications.put("DPY", "ASN"); + modifications.put("DRM", "UR3"); + modifications.put("DRP", "ASN"); + modifications.put("DRT", "THR"); + modifications.put("DRZ", "ASN"); + modifications.put("DSE", "SER"); + modifications.put("DSG", "ASN"); + modifications.put("DSN", "SER"); + modifications.put("DSP", "ASP"); + modifications.put("DT ", "THR"); + modifications.put("DTH", "THR"); + modifications.put("DTR", "TRP"); + modifications.put("DTY", "TYR"); + modifications.put("DU ", "UR3"); + modifications.put("DVA", "VAL"); + modifications.put("DXD", "ASN"); + modifications.put("DXN", "ASN"); + modifications.put("DYG", "DYG"); + modifications.put("DYS", "CYS"); + modifications.put("DZM", "ALA"); + modifications.put("E ", "ALA"); + modifications.put("E1X", "ALA"); + modifications.put("ECC", "GLN"); + modifications.put("EDA", "ALA"); + modifications.put("EFC", "CYS"); + modifications.put("EHP", "PHE"); + modifications.put("EIT", "THR"); + modifications.put("ENP", "ASN"); + modifications.put("ESB", "TYR"); + modifications.put("ESC", "MET"); + modifications.put("EXB", "XAA"); + modifications.put("EXY", "LEU"); + modifications.put("EY5", "ASN"); + modifications.put("EYS", "XAA"); + modifications.put("F2F", "PHE"); + modifications.put("FA2", "ALA"); + modifications.put("FA5", "ASN"); + modifications.put("FAG", "ASN"); + modifications.put("FAI", "ASN"); + modifications.put("FB5", "ALA"); + modifications.put("FB6", "ALA"); + modifications.put("FCL", "PHE"); + modifications.put("FFD", "ASN"); + modifications.put("FGA", "GLU"); + modifications.put("FGL", "GLY"); + modifications.put("FGP", "SER"); + modifications.put("FHL", "XAA"); + modifications.put("FHO", "LYS"); + modifications.put("FHU", "UR3"); + modifications.put("FLA", "ALA"); + modifications.put("FLE", "LEU"); + modifications.put("FLT", "TYR"); + modifications.put("FME", "MET"); + modifications.put("FMG", "GLY"); + modifications.put("FMU", "ASN"); + modifications.put("FOE", "CYS"); + modifications.put("FOX", "GLY"); + modifications.put("FP9", "PRO"); + modifications.put("FPA", "PHE"); + modifications.put("FRD", "XAA"); + modifications.put("FT6", "TRP"); + modifications.put("FTR", "TRP"); + modifications.put("FTY", "TYR"); + modifications.put("FVA", "VAL"); + modifications.put("FZN", "LYS"); + modifications.put("G ", "GLY"); + modifications.put("G25", "GLY"); + modifications.put("G2L", "GLY"); + modifications.put("G2S", "GLY"); + modifications.put("G31", "GLY"); + modifications.put("G32", "GLY"); + modifications.put("G33", "GLY"); + modifications.put("G36", "GLY"); + modifications.put("G38", "GLY"); + modifications.put("G42", "GLY"); + modifications.put("G46", "GLY"); + modifications.put("G47", "GLY"); + modifications.put("G48", "GLY"); + modifications.put("G49", "GLY"); + modifications.put("G4P", "ASN"); + modifications.put("G7M", "GLY"); + modifications.put("GAO", "GLY"); + modifications.put("GAU", "GLU"); + modifications.put("GCK", "CYS"); + modifications.put("GCM", "XAA"); + modifications.put("GDP", "GLY"); + modifications.put("GDR", "GLY"); + modifications.put("GFL", "GLY"); + modifications.put("GGL", "GLU"); + modifications.put("GH3", "GLY"); + modifications.put("GHG", "GLN"); + modifications.put("GHP", "GLY"); + modifications.put("GL3", "GLY"); + modifications.put("GLH", "GLN"); + modifications.put("GLJ", "GLU"); + modifications.put("GLK", "GLU"); + modifications.put("GLM", "XAA"); + modifications.put("GLN", "GLN"); + modifications.put("GLQ", "GLU"); + modifications.put("GLU", "GLU"); + modifications.put("GLX", "GLX"); + modifications.put("GLY", "GLY"); + modifications.put("GLZ", "GLY"); + modifications.put("GMA", "GLU"); + modifications.put("GMS", "GLY"); + modifications.put("GMU", "UR3"); + modifications.put("GN7", "GLY"); + modifications.put("GND", "XAA"); + modifications.put("GNE", "ASN"); + modifications.put("GOM", "GLY"); + modifications.put("GPL", "LYS"); + modifications.put("GS ", "GLY"); + modifications.put("GSC", "GLY"); + modifications.put("GSR", "GLY"); + modifications.put("GSS", "GLY"); + modifications.put("GSU", "GLU"); + modifications.put("GT9", "CYS"); + modifications.put("GTP", "GLY"); + modifications.put("GVL", "XAA"); + modifications.put("GYC", "CYG"); + modifications.put("GYS", "SYG"); + modifications.put("H2U", "UR3"); + modifications.put("H5M", "PRO"); + modifications.put("HAC", "ALA"); + modifications.put("HAR", "ARG"); + modifications.put("HBN", "HIS"); + modifications.put("HCS", "XAA"); + modifications.put("HDP", "UR3"); + modifications.put("HEU", "UR3"); + modifications.put("HFA", "XAA"); + modifications.put("HGL", "XAA"); + modifications.put("HHI", "HIS"); + modifications.put("HHK", "AK"); // check + modifications.put("HIA", "HIS"); + modifications.put("HIC", "HIS"); + modifications.put("HIP", "HIS"); + modifications.put("HIQ", "HIS"); + modifications.put("HIS", "HIS"); + modifications.put("HL2", "LEU"); + modifications.put("HLU", "LEU"); + modifications.put("HMR", "ARG"); + modifications.put("HOL", "ASN"); + modifications.put("HPC", "PHE"); + modifications.put("HPE", "PHE"); + modifications.put("HPH", "PHE"); + modifications.put("HPQ", "PHE"); + modifications.put("HQA", "ALA"); + modifications.put("HRG", "ARG"); + modifications.put("HRP", "TRP"); + modifications.put("HS8", "HIS"); + modifications.put("HS9", "HIS"); + modifications.put("HSE", "SER"); + modifications.put("HSL", "SER"); + modifications.put("HSO", "HIS"); + modifications.put("HTI", "CYS"); + modifications.put("HTN", "ASN"); + modifications.put("HTR", "TRP"); + modifications.put("HV5", "ALA"); + modifications.put("HVA", "VAL"); + modifications.put("HY3", "PRO"); + modifications.put("HYP", "PRO"); + modifications.put("HZP", "PRO"); + modifications.put("I ", "ILE"); + modifications.put("I2M", "ILE"); + modifications.put("I58", "LYS"); + modifications.put("I5C", "CYS"); + modifications.put("IAM", "ALA"); + modifications.put("IAR", "ARG"); + modifications.put("IAS", "ASP"); + modifications.put("IC ", "CYS"); + modifications.put("IEL", "LYS"); + modifications.put("IEY", "HYG"); + modifications.put("IG ", "GLY"); + modifications.put("IGL", "GLY"); + modifications.put("IGU", "GLY"); + modifications.put("IIC", "SHG"); + modifications.put("IIL", "ILE"); + modifications.put("ILE", "ILE"); + modifications.put("ILG", "GLU"); + modifications.put("ILX", "ILE"); + modifications.put("IMC", "CYS"); + modifications.put("IML", "ILE"); + modifications.put("IOY", "PHE"); + modifications.put("IPG", "GLY"); + modifications.put("IPN", "ASN"); + modifications.put("IRN", "ASN"); + modifications.put("IT1", "LYS"); + modifications.put("IU ", "UR3"); + modifications.put("IYR", "TYR"); + modifications.put("IYT", "THR"); + modifications.put("IZO", "MET"); + modifications.put("JJJ", "CYS"); + modifications.put("JJK", "CYS"); + modifications.put("JJL", "CYS"); + modifications.put("JW5", "ASN"); + modifications.put("K1R", "CYS"); + modifications.put("KAG", "GLY"); + modifications.put("KCX", "LYS"); + modifications.put("KGC", "LYS"); + modifications.put("KNB", "ALA"); + modifications.put("KOR", "MET"); + modifications.put("KPI", "LYS"); + modifications.put("KST", "LYS"); + modifications.put("KYQ", "LYS"); + modifications.put("L2A", "XAA"); + modifications.put("LA2", "LYS"); + modifications.put("LAA", "ASP"); + modifications.put("LAL", "ALA"); + modifications.put("LBY", "LYS"); + modifications.put("LC ", "CYS"); + modifications.put("LCA", "ALA"); + modifications.put("LCC", "ASN"); + modifications.put("LCG", "GLY"); + modifications.put("LCH", "ASN"); + modifications.put("LCK", "LYS"); + modifications.put("LCX", "LYS"); + modifications.put("LDH", "LYS"); + modifications.put("LED", "LEU"); + modifications.put("LEF", "LEU"); + modifications.put("LEH", "LEU"); + modifications.put("LEI", "VAL"); + modifications.put("LEM", "LEU"); + modifications.put("LEN", "LEU"); + modifications.put("LET", "XAA"); + modifications.put("LEU", "LEU"); + modifications.put("LEX", "LEU"); + modifications.put("LG ", "GLY"); + modifications.put("LGP", "GLY"); + modifications.put("LHC", "XAA"); + modifications.put("LHU", "UR3"); + modifications.put("LKC", "ASN"); + modifications.put("LLP", "LYS"); + modifications.put("LLY", "LYS"); + modifications.put("LME", "GLU"); + modifications.put("LMF", "LYS"); + modifications.put("LMQ", "GLN"); + modifications.put("LMS", "ASN"); + modifications.put("LP6", "LYS"); + modifications.put("LPD", "PRO"); + modifications.put("LPG", "GLY"); + modifications.put("LPL", "XAA"); + modifications.put("LPS", "SER"); + modifications.put("LSO", "XAA"); + modifications.put("LTA", "XAA"); + modifications.put("LTR", "TRP"); + modifications.put("LVG", "GLY"); + modifications.put("LVN", "VAL"); + modifications.put("LYF", "LYS"); + modifications.put("LYK", "LYS"); + modifications.put("LYM", "LYS"); + modifications.put("LYN", "LYS"); + modifications.put("LYR", "LYS"); + modifications.put("LYS", "LYS"); + modifications.put("LYX", "LYS"); + modifications.put("LYZ", "LYS"); + modifications.put("M0H", "CYS"); + modifications.put("M1G", "GLY"); + modifications.put("M2G", "GLY"); + modifications.put("M2L", "LYS"); + modifications.put("M2S", "MET"); + modifications.put("M30", "GLY"); + modifications.put("M3L", "LYS"); + modifications.put("M5M", "CYS"); + modifications.put("MA ", "ALA"); + modifications.put("MA6", "ALA"); + modifications.put("MA7", "ALA"); + modifications.put("MAA", "ALA"); + modifications.put("MAD", "ALA"); + modifications.put("MAI", "ARG"); + modifications.put("MBQ", "TYR"); + modifications.put("MBZ", "ASN"); + modifications.put("MC1", "SER"); + modifications.put("MCG", "XAA"); + modifications.put("MCL", "LYS"); + modifications.put("MCS", "CYS"); + modifications.put("MCY", "CYS"); + modifications.put("MD3", "CYS"); + modifications.put("MD6", "GLY"); + modifications.put("MDH", "XAA"); + modifications.put("MDO", "ASG"); + modifications.put("MDR", "ASN"); + modifications.put("MEA", "PHE"); + modifications.put("MED", "MET"); + modifications.put("MEG", "GLU"); + modifications.put("MEN", "ASN"); + modifications.put("MEP", "UR3"); + modifications.put("MEQ", "GLN"); + modifications.put("MET", "MET"); + modifications.put("MEU", "GLY"); + modifications.put("MF3", "XAA"); + modifications.put("MFC", "GYG"); + modifications.put("MG1", "GLY"); + modifications.put("MGG", "ARG"); + modifications.put("MGN", "GLN"); + modifications.put("MGQ", "ALA"); + modifications.put("MGV", "GLY"); + modifications.put("MGY", "GLY"); + modifications.put("MHL", "LEU"); + modifications.put("MHO", "MET"); + modifications.put("MHS", "HIS"); + modifications.put("MIA", "ALA"); + modifications.put("MIS", "SER"); + modifications.put("MK8", "LEU"); + modifications.put("ML3", "LYS"); + modifications.put("MLE", "LEU"); + modifications.put("MLL", "LEU"); + modifications.put("MLY", "LYS"); + modifications.put("MLZ", "LYS"); + modifications.put("MME", "MET"); + modifications.put("MMO", "ARG"); + modifications.put("MMT", "THR"); + modifications.put("MND", "ASN"); + modifications.put("MNL", "LEU"); + modifications.put("MNU", "UR3"); + modifications.put("MNV", "VAL"); + modifications.put("MOD", "XAA"); + modifications.put("MP8", "PRO"); + modifications.put("MPH", "XAA"); + modifications.put("MPJ", "XAA"); + modifications.put("MPQ", "GLY"); + modifications.put("MRG", "GLY"); + modifications.put("MSA", "GLY"); + modifications.put("MSE", "MET"); + modifications.put("MSL", "MET"); + modifications.put("MSO", "MET"); + modifications.put("MSP", "XAA"); + modifications.put("MT2", "MET"); + modifications.put("MTR", "THR"); + modifications.put("MTU", "ALA"); + modifications.put("MTY", "TYR"); + modifications.put("MVA", "VAL"); + modifications.put("N ", "ASN"); + modifications.put("N10", "SER"); + modifications.put("N2C", "XAA"); + modifications.put("N5I", "ASN"); + modifications.put("N5M", "CYS"); + modifications.put("N6G", "GLY"); + modifications.put("N7P", "PRO"); + modifications.put("NA8", "ALA"); + modifications.put("NAL", "ALA"); + modifications.put("NAM", "ALA"); + modifications.put("NB8", "ASN"); + modifications.put("NBQ", "TYR"); + modifications.put("NC1", "SER"); + modifications.put("NCB", "ALA"); + modifications.put("NCX", "ASN"); + modifications.put("NCY", "XAA"); + modifications.put("NDF", "PHE"); + modifications.put("NDN", "UR3"); + modifications.put("NEM", "HIS"); + modifications.put("NEP", "HIS"); + modifications.put("NF2", "ASN"); + modifications.put("NFA", "PHE"); + modifications.put("NHL", "GLU"); + modifications.put("NIT", "XAA"); + modifications.put("NIY", "TYR"); + modifications.put("NLE", "LEU"); + modifications.put("NLN", "LEU"); + modifications.put("NLO", "LEU"); + modifications.put("NLP", "LEU"); + modifications.put("NLQ", "GLN"); + modifications.put("NMC", "GLY"); + modifications.put("NMM", "ARG"); + modifications.put("NMS", "THR"); + modifications.put("NMT", "THR"); + modifications.put("NNH", "ARG"); + modifications.put("NP3", "ASN"); + modifications.put("NPH", "CYS"); + modifications.put("NPI", "ALA"); + modifications.put("NRP", "LYG"); + modifications.put("NRQ", "MYG"); + modifications.put("NSK", "XAA"); + modifications.put("NTY", "TYR"); + modifications.put("NVA", "VAL"); + modifications.put("NYC", "TWG"); + modifications.put("NYG", "NYG"); + modifications.put("NYM", "ASN"); + modifications.put("NYS", "CYS"); + modifications.put("NZH", "HIS"); + modifications.put("O12", "XAA"); + modifications.put("O2C", "ASN"); + modifications.put("O2G", "GLY"); + modifications.put("OAD", "ASN"); + modifications.put("OAS", "SER"); + modifications.put("OBF", "XAA"); + modifications.put("OBS", "XAA"); + modifications.put("OCS", "CYS"); + modifications.put("OCY", "CYS"); + modifications.put("ODP", "ASN"); + modifications.put("OHI", "HIS"); + modifications.put("OHS", "ASP"); + modifications.put("OIC", "XAA"); + modifications.put("OIP", "ILE"); + modifications.put("OLE", "XAA"); + modifications.put("OLT", "THR"); + modifications.put("OLZ", "SER"); + modifications.put("OMC", "CYS"); + modifications.put("OMG", "GLY"); + modifications.put("OMT", "MET"); + modifications.put("OMU", "UR3"); + modifications.put("ONE", "UR3"); + modifications.put("ONH", "ALA"); + modifications.put("ONL", "XAA"); + modifications.put("OPR", "ARG"); + modifications.put("ORN", "ALA"); + modifications.put("ORQ", "ARG"); + modifications.put("OSE", "SER"); + modifications.put("OTB", "XAA"); + modifications.put("OTH", "THR"); + modifications.put("OTY", "TYR"); + modifications.put("OXX", "ASP"); + modifications.put("P ", "GLY"); + modifications.put("P1L", "CYS"); + modifications.put("P1P", "ASN"); + modifications.put("P2T", "THR"); + modifications.put("P2U", "UR3"); + modifications.put("P2Y", "PRO"); + modifications.put("P5P", "ALA"); + modifications.put("PAQ", "TYR"); + modifications.put("PAS", "ASP"); + modifications.put("PAT", "TRP"); + modifications.put("PAU", "ALA"); + modifications.put("PBB", "CYS"); + modifications.put("PBF", "PHE"); + modifications.put("PBT", "ASN"); + modifications.put("PCA", "GLU"); + modifications.put("PCC", "PRO"); + modifications.put("PCE", "XAA"); + modifications.put("PCS", "PHE"); + modifications.put("PDL", "XAA"); + modifications.put("PDU", "UR3"); + modifications.put("PEC", "CYS"); + modifications.put("PF5", "PHE"); + modifications.put("PFF", "PHE"); + modifications.put("PFX", "XAA"); + modifications.put("PG1", "SER"); + modifications.put("PG7", "GLY"); + modifications.put("PG9", "GLY"); + modifications.put("PGL", "XAA"); + modifications.put("PGN", "GLY"); + modifications.put("PGP", "GLY"); + modifications.put("PGY", "GLY"); + modifications.put("PHA", "PHE"); + modifications.put("PHD", "ASP"); + modifications.put("PHE", "PHE"); + modifications.put("PHI", "PHE"); + modifications.put("PHL", "PHE"); + modifications.put("PHM", "PHE"); + modifications.put("PIA", "AYG"); + modifications.put("PIV", "XAA"); + modifications.put("PLE", "LEU"); + modifications.put("PM3", "PHE"); + modifications.put("PMT", "CYS"); + modifications.put("POM", "PRO"); + modifications.put("PPN", "PHE"); + modifications.put("PPU", "ALA"); + modifications.put("PPW", "GLY"); + modifications.put("PQ1", "ASN"); + modifications.put("PR3", "CYS"); + modifications.put("PR5", "ALA"); + modifications.put("PR9", "PRO"); + modifications.put("PRN", "ALA"); + modifications.put("PRO", "PRO"); + modifications.put("PRS", "PRO"); + modifications.put("PSA", "PHE"); + modifications.put("PSH", "HIS"); + modifications.put("PST", "THR"); + modifications.put("PSU", "UR3"); + modifications.put("PSW", "CYS"); + modifications.put("PTA", "XAA"); + modifications.put("PTH", "TYR"); + modifications.put("PTM", "TYR"); + modifications.put("PTR", "TYR"); + modifications.put("PU ", "ALA"); + modifications.put("PUY", "ASN"); + modifications.put("PVH", "HIS"); + modifications.put("PVL", "XAA"); + modifications.put("PYA", "ALA"); + modifications.put("PYO", "UR3"); + modifications.put("PYX", "CYS"); + modifications.put("PYY", "ASN"); + modifications.put("QLG", "QLG"); + modifications.put("QMM", "GLN"); + modifications.put("QPA", "CYS"); + modifications.put("QPH", "PHE"); + modifications.put("QUO", "GLY"); + modifications.put("R ", "ALA"); + modifications.put("R1A", "CYS"); + modifications.put("R4K", "TRP"); + modifications.put("RC7", "HYG"); + modifications.put("RE0", "TRP"); + modifications.put("RE3", "TRP"); + modifications.put("RIA", "ALA"); + modifications.put("RMP", "ALA"); + modifications.put("RON", "XAA"); + modifications.put("RT ", "THR"); + modifications.put("RTP", "ASN"); + modifications.put("S1H", "SER"); + modifications.put("S2C", "CYS"); + modifications.put("S2D", "ALA"); + modifications.put("S2M", "THR"); + modifications.put("S2P", "ALA"); + modifications.put("S4A", "ALA"); + modifications.put("S4C", "CYS"); + modifications.put("S4G", "GLY"); + modifications.put("S4U", "UR3"); + modifications.put("S6G", "GLY"); + modifications.put("SAC", "SER"); + modifications.put("SAH", "CYS"); + modifications.put("SAR", "GLY"); + modifications.put("SBL", "SER"); + modifications.put("SC ", "CYS"); + modifications.put("SCH", "CYS"); + modifications.put("SCS", "CYS"); + modifications.put("SCY", "CYS"); + modifications.put("SD2", "XAA"); + modifications.put("SDG", "GLY"); + modifications.put("SDP", "SER"); + modifications.put("SEB", "SER"); + modifications.put("SEC", "ALA"); + modifications.put("SEG", "ALA"); + modifications.put("SEL", "SER"); + modifications.put("SEM", "SER"); + modifications.put("SEN", "SER"); + modifications.put("SEP", "SER"); + modifications.put("SER", "SER"); + modifications.put("SET", "SER"); + modifications.put("SGB", "SER"); + modifications.put("SHC", "CYS"); + modifications.put("SHP", "GLY"); + modifications.put("SHR", "LYS"); + modifications.put("SIB", "CYS"); + modifications.put("SIC", "DC"); // check + modifications.put("SLA", "PRO"); + modifications.put("SLR", "PRO"); + modifications.put("SLZ", "LYS"); + modifications.put("SMC", "CYS"); + modifications.put("SME", "MET"); + modifications.put("SMF", "PHE"); + modifications.put("SMP", "ALA"); + modifications.put("SMT", "THR"); + modifications.put("SNC", "CYS"); + modifications.put("SNN", "ASN"); + modifications.put("SOC", "CYS"); + modifications.put("SOS", "ASN"); + modifications.put("SOY", "SER"); + modifications.put("SPT", "THR"); + modifications.put("SRA", "ALA"); + modifications.put("SSU", "UR3"); + modifications.put("STY", "TYR"); + modifications.put("SUB", "XAA"); + modifications.put("SUI", "DG"); + modifications.put("SUN", "SER"); + modifications.put("SUR", "UR3"); + modifications.put("SVA", "SER"); + modifications.put("SVV", "SER"); + modifications.put("SVW", "SER"); + modifications.put("SVX", "SER"); + modifications.put("SVY", "SER"); + modifications.put("SVZ", "XAA"); + modifications.put("SWG", "SWG"); + modifications.put("SYS", "CYS"); + modifications.put("T ", "THR"); + modifications.put("T11", "PHE"); + modifications.put("T23", "THR"); + modifications.put("T2S", "THR"); + modifications.put("T2T", "ASN"); + modifications.put("T31", "UR3"); + modifications.put("T32", "THR"); + modifications.put("T36", "THR"); + modifications.put("T37", "THR"); + modifications.put("T38", "THR"); + modifications.put("T39", "THR"); + modifications.put("T3P", "THR"); + modifications.put("T41", "THR"); + modifications.put("T48", "THR"); + modifications.put("T49", "THR"); + modifications.put("T4S", "THR"); + modifications.put("T5O", "UR3"); + modifications.put("T5S", "THR"); + modifications.put("T66", "XAA"); + modifications.put("T6A", "ALA"); + modifications.put("TA3", "THR"); + modifications.put("TA4", "XAA"); + modifications.put("TAF", "THR"); + modifications.put("TAL", "ASN"); + modifications.put("TAV", "ASP"); + modifications.put("TBG", "VAL"); + modifications.put("TBM", "THR"); + modifications.put("TC1", "CYS"); + modifications.put("TCP", "THR"); + modifications.put("TCQ", "TYR"); + modifications.put("TCR", "TRP"); + modifications.put("TCY", "ALA"); + modifications.put("TDD", "LEU"); + modifications.put("TDY", "THR"); + modifications.put("TFE", "THR"); + modifications.put("TFO", "ALA"); + modifications.put("TFQ", "PHE"); + modifications.put("TFT", "THR"); + modifications.put("TGP", "GLY"); + modifications.put("TH6", "THR"); + modifications.put("THC", "THR"); + modifications.put("THO", "XAA"); + modifications.put("THR", "THR"); + modifications.put("THX", "ASN"); + modifications.put("THZ", "ARG"); + modifications.put("TIH", "ALA"); + modifications.put("TLB", "ASN"); + modifications.put("TLC", "THR"); + modifications.put("TLN", "UR3"); + modifications.put("TMB", "THR"); + modifications.put("TMD", "THR"); + modifications.put("TNB", "CYS"); + modifications.put("TNR", "SER"); + modifications.put("TOX", "TRP"); + modifications.put("TP1", "THR"); + modifications.put("TPC", "CYS"); + modifications.put("TPG", "GLY"); + modifications.put("TPH", "XAA"); + modifications.put("TPL", "TRP"); + modifications.put("TPO", "THR"); + modifications.put("TPQ", "TYR"); + modifications.put("TQI", "TRP"); + modifications.put("TQQ", "TRP"); + modifications.put("TRF", "TRP"); + modifications.put("TRG", "LYS"); + modifications.put("TRN", "TRP"); + modifications.put("TRO", "TRP"); + modifications.put("TRP", "TRP"); + modifications.put("TRQ", "TRP"); + modifications.put("TRW", "TRP"); + modifications.put("TRX", "TRP"); + modifications.put("TS ", "ASN"); + modifications.put("TST", "XAA"); + modifications.put("TT ", "ASN"); + modifications.put("TTD", "THR"); + modifications.put("TTI", "UR3"); + modifications.put("TTM", "THR"); + modifications.put("TTQ", "TRP"); + modifications.put("TTS", "TYR"); + modifications.put("TY1", "TYR"); + modifications.put("TY2", "TYR"); + modifications.put("TY3", "TYR"); + modifications.put("TY5", "TYR"); + modifications.put("TYB", "TYR"); + modifications.put("TYI", "TYR"); + modifications.put("TYJ", "TYR"); + modifications.put("TYN", "TYR"); + modifications.put("TYO", "TYR"); + modifications.put("TYQ", "TYR"); + modifications.put("TYR", "TYR"); + modifications.put("TYS", "TYR"); + modifications.put("TYT", "TYR"); + modifications.put("TYU", "ASN"); + modifications.put("TYW", "TYR"); + modifications.put("TYX", "XAA"); + modifications.put("TYY", "TYR"); + modifications.put("TZB", "XAA"); + modifications.put("TZO", "XAA"); + modifications.put("U ", "UR3"); + modifications.put("U25", "UR3"); + modifications.put("U2L", "UR3"); + modifications.put("U2N", "UR3"); + modifications.put("U2P", "UR3"); + modifications.put("U31", "UR3"); + modifications.put("U33", "UR3"); + modifications.put("U34", "UR3"); + modifications.put("U36", "UR3"); + modifications.put("U37", "UR3"); + modifications.put("U8U", "UR3"); + modifications.put("UAR", "UR3"); + modifications.put("UCL", "UR3"); + modifications.put("UD5", "UR3"); + modifications.put("UDP", "ASN"); + modifications.put("UFP", "ASN"); + modifications.put("UFR", "UR3"); + modifications.put("UFT", "UR3"); + modifications.put("UMA", "ALA"); + modifications.put("UMP", "UR3"); + modifications.put("UMS", "UR3"); + modifications.put("UN1", "XAA"); + modifications.put("UN2", "XAA"); + modifications.put("UNK", "XAA"); + modifications.put("UR3", "UR3"); + modifications.put("URD", "UR3"); + modifications.put("US1", "UR3"); + modifications.put("US2", "UR3"); + modifications.put("US3", "THR"); + modifications.put("US5", "UR3"); + modifications.put("USM", "UR3"); + modifications.put("VAD", "VAL"); + modifications.put("VAF", "VAL"); + modifications.put("VAL", "VAL"); + modifications.put("VB1", "LYS"); + modifications.put("VDL", "XAA"); + modifications.put("VLL", "XAA"); + modifications.put("VLM", "XAA"); + modifications.put("VMS", "XAA"); + modifications.put("VOL", "XAA"); + modifications.put("WCR", "GYG"); + modifications.put("X ", "GLY"); + modifications.put("X2W", "GLU"); + modifications.put("X4A", "ASN"); + modifications.put("X9Q", "AFG"); + modifications.put("XAD", "ALA"); + modifications.put("XAE", "ASN"); + modifications.put("XAL", "ALA"); + modifications.put("XAR", "ASN"); + modifications.put("XCL", "CYS"); + modifications.put("XCN", "CYS"); + modifications.put("XCP", "XAA"); + modifications.put("XCR", "CYS"); + modifications.put("XCS", "ASN"); + modifications.put("XCT", "CYS"); + modifications.put("XCY", "CYS"); + modifications.put("XGA", "ASN"); + modifications.put("XGL", "GLY"); + modifications.put("XGR", "GLY"); + modifications.put("XGU", "GLY"); + modifications.put("XPR", "PRO"); + modifications.put("XSN", "ASN"); + modifications.put("XTH", "THR"); + modifications.put("XTL", "THR"); + modifications.put("XTR", "THR"); + modifications.put("XTS", "GLY"); + modifications.put("XTY", "ASN"); + modifications.put("XUA", "ALA"); + modifications.put("XUG", "GLY"); + modifications.put("XX1", "LYS"); + modifications.put("XXY", "THG"); + modifications.put("XYG", "DYG"); + modifications.put("Y ", "ALA"); + modifications.put("YCM", "CYS"); + modifications.put("YG ", "GLY"); + modifications.put("YOF", "TYR"); + modifications.put("YRR", "ASN"); + modifications.put("YYG", "GLY"); + modifications.put("Z ", "CYS"); + modifications.put("Z01", "ALA"); + modifications.put("ZAD", "ALA"); + modifications.put("ZAL", "ALA"); + modifications.put("ZBC", "CYS"); + modifications.put("ZBU", "UR3"); + modifications.put("ZCL", "PHE"); + modifications.put("ZCY", "CYS"); + modifications.put("ZDU", "UR3"); + modifications.put("ZFB", "XAA"); + modifications.put("ZGU", "GLY"); + modifications.put("ZHP", "ASN"); + modifications.put("ZTH", "THR"); + modifications.put("ZU0", "THR"); + modifications.put("ZZJ", "ALA"); + } public static String getCanonicalAminoAcid(String aa) diff --git a/src/jalview/ws/sifts/SiftsClient.java b/src/jalview/ws/sifts/SiftsClient.java index 7d5ae2e..9f7bc52 100644 --- a/src/jalview/ws/sifts/SiftsClient.java +++ b/src/jalview/ws/sifts/SiftsClient.java @@ -546,7 +546,8 @@ public class SiftsClient implements SiftsClientI || seqCoordSys == CoordinateSys.UNIPROT) { char resCharCode = ResidueProperties - .getSingleCharacterCode(residue.getDbResName()); + .getSingleCharacterCode(ResidueProperties + .getCanonicalAminoAcid(residue.getDbResName())); resNumMap.put(currSeqIndex, String.valueOf(resCharCode)); } else diff --git a/test/jalview/schemes/ResiduePropertiesTest.java b/test/jalview/schemes/ResiduePropertiesTest.java index 4dff315..b68ca68 100644 --- a/test/jalview/schemes/ResiduePropertiesTest.java +++ b/test/jalview/schemes/ResiduePropertiesTest.java @@ -242,6 +242,1307 @@ public class ResiduePropertiesTest { assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MET")); assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MSE")); + + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("00C")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("01W")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("02K")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("03Y")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("07O")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("08P")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("0A0")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("0A1")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("0A2")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("0A8")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("0AA")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("0AB")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("0AC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("0AD")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("0AF")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("0AG")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("0AH")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("0AK")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0AM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("0AP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("0AU")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0AV")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("0AZ")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("0BN")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("0C ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0CS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("0DC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("0DG")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("0DT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0FL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("0G ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0NC")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("0SP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("0U ")); + assertEquals("YG", ResidueProperties.getCanonicalAminoAcid("0YG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("10C")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("125")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("126")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("127")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("128")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("12A")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("143")); + assertEquals("ASG", ResidueProperties.getCanonicalAminoAcid("175")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("193")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("1AP")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("1MA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("1MG")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("1PA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("1PI")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("1PR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("1SC")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("1TQ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("1TY")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("1X6")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("200")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("23F")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("23S")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("26B")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2AD")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("2AG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2AO")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("2AR")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2AS")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2AT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("2AU")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("2BD")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2BT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("2BU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("2CO")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("2DA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("2DF")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("2DM")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2DO")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2DT")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("2EG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("2FE")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("2FI")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("2FM")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2GT")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("2HF")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("2LU")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("2MA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("2MG")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("2ML")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("2MR")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("2MT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("2MU")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2NT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("2OM")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2OT")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2PI")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("2PR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("2SA")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("2SI")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2ST")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("2TL")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("2TY")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("2VA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("2XA")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("32S")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("32T")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("3AH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("3AR")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("3CF")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("3DA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("3DR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("3GA")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("3MD")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("3ME")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("3NF")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("3QN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("3TY")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("3XH")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("4AC")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("4BF")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("4CF")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("4CY")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("4DP")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("4F3")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("4FB")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("4FW")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("4HT")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("4IN")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("4MF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("4MM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("4OC")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("4PC")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("4PD")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("4PE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("4PH")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("4SC")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("4SU")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("4TA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("4U7")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("56A")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("5AA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("5AB")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("5AT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5BU")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("5CG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5CM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5CS")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("5FA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5FC")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5FU")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("5HP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("5HT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5HU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5IC")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("5IT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5IU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5MC")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("5MD")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5MU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5NC")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("5PC")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("5PY")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("5SE")); + assertEquals("TWG", ResidueProperties.getCanonicalAminoAcid("5ZA")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("64T")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("6CL")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("6CT")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("6CW")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("6HA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("6HC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("6HG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("6HN")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("6HT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("6IA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("6MA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("6MC")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("6MI")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("6MT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("6MZ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("6OG")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("70U")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("7DA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("7GU")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("7JA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("7MG")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("8AN")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("8FG")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("8MG")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("8OG")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("9NE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("9NF")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("9NR")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("9NV")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("A1P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A23")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A2L")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A2M")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A34")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A35")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A38")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A39")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A3A")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A3P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A40")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A43")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A44")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A47")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A5L")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("A5M")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("A5N")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("A5O")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("A66")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AA3")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AA4")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("AAR")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AB7")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ABA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ABR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ABS")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ABT")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ACB")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("ACL")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AD2")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ADD")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ADX")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AEA")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("AEI")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AET")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("AFA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("AFF")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("AFG")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("AGM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("AGT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("AHB")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AHH")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AHO")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AHP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AHS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AHT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AIB")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("AKL")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("AKZ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALC")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALM")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALN")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ALO")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ALQ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALS")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ALV")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("ALY")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AN8")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AP7")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("APE")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("APH")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("API")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("APK")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("APM")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("APP")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("AR2")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("AR4")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("AR7")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("ARG")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("ARM")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("ARO")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ARV")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AS ")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("AS2")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AS9")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASA")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASB")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASI")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASK")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASL")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ASM")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ASN")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASP")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("ASQ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ASU")); + assertEquals("ASX", ResidueProperties.getCanonicalAminoAcid("ASX")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ATD")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ATL")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ATM")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AVC")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("AVN")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("AYA")); + assertEquals("AYG", ResidueProperties.getCanonicalAminoAcid("AYG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("AZK")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("AZS")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("AZY")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("B1F")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("B1P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("B2A")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("B2F")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("B2I")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("B2V")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("B3A")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("B3D")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("B3E")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("B3K")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("B3L")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("B3M")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("B3Q")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("B3S")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("B3T")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("B3U")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("B3X")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("B3Y")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BB6")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BB7")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("BB8")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BB9")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BBC")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BCS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("BE2")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("BFD")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("BG1")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("BGM")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("BH2")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("BHD")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("BIF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("BIL")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("BIU")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("BJH")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("BLE")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("BLY")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("BMP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("BMT")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("BNN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("BNO")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("BOE")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("BOR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BPE")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("BRU")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("BSE")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("BT5")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("BTA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BTC")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("BTR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("BUC")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("BUG")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("BVP")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("BZG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C ")); + assertEquals("TYG", ResidueProperties.getCanonicalAminoAcid("C12")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("C1X")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C25")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C2L")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C2S")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C31")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C32")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C34")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C36")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C37")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C38")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C3Y")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C42")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C43")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C45")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C46")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C49")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C4R")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C4S")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C5C")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("C66")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("C6C")); + assertEquals("TFG", ResidueProperties.getCanonicalAminoAcid("C99")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CAF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CAL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CAR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CAS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CAV")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CAY")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CB2")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CBR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CBV")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CCC")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("CCL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CCS")); + assertEquals("CYG", ResidueProperties.getCanonicalAminoAcid("CCY")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CDE")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CDV")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CDW")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CEA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CFL")); + assertEquals("FCYG", ResidueProperties.getCanonicalAminoAcid("CFY")); // check + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("CG1")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("CGA")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("CGU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CH ")); + assertEquals("MYG", ResidueProperties.getCanonicalAminoAcid("CH6")); + assertEquals("KYG", ResidueProperties.getCanonicalAminoAcid("CH7")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CHF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CHG")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("CHP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CHS")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("CIR")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("CJO")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("CLE")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("CLG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("CLH")); + assertEquals("AFG", ResidueProperties.getCanonicalAminoAcid("CLV")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("CM0")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CME")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CMH")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CML")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CMR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CMT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("CNU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CP1")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CPC")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CPI")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("CQR")); + assertEquals("TLG", ResidueProperties.getCanonicalAminoAcid("CR0")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("CR2")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("CR5")); + assertEquals("KYG", ResidueProperties.getCanonicalAminoAcid("CR7")); + assertEquals("HYG", ResidueProperties.getCanonicalAminoAcid("CR8")); + assertEquals("TWG", ResidueProperties.getCanonicalAminoAcid("CRF")); + assertEquals("THG", ResidueProperties.getCanonicalAminoAcid("CRG")); + assertEquals("MYG", ResidueProperties.getCanonicalAminoAcid("CRK")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("CRO")); + assertEquals("QYG", ResidueProperties.getCanonicalAminoAcid("CRQ")); + assertEquals("EYG", ResidueProperties.getCanonicalAminoAcid("CRU")); + assertEquals("ASG", ResidueProperties.getCanonicalAminoAcid("CRW")); + assertEquals("ASG", ResidueProperties.getCanonicalAminoAcid("CRX")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CS0")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CS1")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CS3")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CS4")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("CS8")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSB")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSD")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSE")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSF")); + assertEquals("SHG", ResidueProperties.getCanonicalAminoAcid("CSH")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("CSI")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSJ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSO")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSP")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSW")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSX")); + assertEquals("SYG", ResidueProperties.getCanonicalAminoAcid("CSY")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CSZ")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("CTE")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("CTG")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("CTH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CUC")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("CWR")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("CXM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CY0")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CY1")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CY3")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CY4")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYD")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYF")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("CYJ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYQ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CYS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CZ2")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("CZO")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("CZZ")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("D11")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("D1P")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("D3 ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("D33")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("D3P")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("D3T")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("D4M")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("D4P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DA ")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DA2")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DAB")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("DAH")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DAL")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("DAR")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("DAS")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DBB")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DBM")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("DBS")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DBU")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("DBY")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DBZ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DC ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DC2")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DCG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DCI")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DCL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DCT")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DCY")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("DDE")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DDG")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("DDN")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DDX")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DFC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DFG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DFI")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DFO")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DFT")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DG ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DGH")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("DGI")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("DGL")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("DGN")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("DHA")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("DHI")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DHL")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("DHN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DHP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("DHU")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("DHV")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("DI ")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("DIL")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("DIR")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("DIV")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("DLE")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("DLS")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("DLY")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("DM0")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DMH")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("DMK")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DMT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DN ")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("DNE")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("DNG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("DNL")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("DNM")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DNP")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DNR")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("DNS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("DOA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DOC")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("DOH")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("DON")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DPB")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("DPH")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("DPL")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DPP")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("DPQ")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("DPR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DPY")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("DRM")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DRP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DRT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DRZ")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("DSE")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DSG")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("DSN")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("DSP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DT ")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("DTH")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("DTR")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("DTY")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("DU ")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("DVA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DXD")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("DXN")); + assertEquals("DYG", ResidueProperties.getCanonicalAminoAcid("DYG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("DYS")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("DZM")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("E ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("E1X")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("ECC")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("EDA")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("EFC")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("EHP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("EIT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ENP")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("ESB")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("ESC")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("EXB")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("EXY")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("EY5")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("EYS")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("F2F")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("FA2")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("FA5")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("FAG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("FAI")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("FB5")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("FB6")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("FCL")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("FFD")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("FGA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("FGL")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("FGP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("FHL")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("FHO")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("FHU")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("FLA")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("FLE")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("FLT")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("FME")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("FMG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("FMU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("FOE")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("FOX")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("FP9")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("FPA")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("FRD")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("FT6")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("FTR")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("FTY")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("FVA")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("FZN")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G25")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G2L")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G2S")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G31")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G32")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G33")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G36")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G38")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G42")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G46")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G47")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G48")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G49")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("G4P")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("G7M")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GAO")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GAU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("GCK")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("GCM")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GDP")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GDR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GFL")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GGL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GH3")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("GHG")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GHP")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GL3")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("GLH")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GLJ")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GLK")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("GLM")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("GLN")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GLQ")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GLU")); + assertEquals("GLX", ResidueProperties.getCanonicalAminoAcid("GLX")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GLY")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GLZ")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GMA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GMS")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("GMU")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GN7")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("GND")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("GNE")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GOM")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("GPL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GS ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GSC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GSR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GSS")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("GSU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("GT9")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("GTP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("GVL")); + assertEquals("CYG", ResidueProperties.getCanonicalAminoAcid("GYC")); + assertEquals("SYG", ResidueProperties.getCanonicalAminoAcid("GYS")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("H2U")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("H5M")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("HAC")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("HAR")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HBN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("HCS")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("HDP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("HEU")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("HFA")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("HGL")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HHI")); + assertEquals("AK", ResidueProperties.getCanonicalAminoAcid("HHK")); // check + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HIA")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HIC")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HIP")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HIQ")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HIS")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("HL2")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("HLU")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("HMR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("HOL")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("HPC")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("HPE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("HPH")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("HPQ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("HQA")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("HRG")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("HRP")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HS8")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HS9")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("HSE")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("HSL")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("HSO")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("HTI")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("HTN")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("HTR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("HV5")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("HVA")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("HY3")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("HYP")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("HZP")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("I ")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("I2M")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("I58")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("I5C")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("IAM")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("IAR")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("IAS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("IC ")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("IEL")); + assertEquals("HYG", ResidueProperties.getCanonicalAminoAcid("IEY")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("IG ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("IGL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("IGU")); + assertEquals("SHG", ResidueProperties.getCanonicalAminoAcid("IIC")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("IIL")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("ILE")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("ILG")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("ILX")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("IMC")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("IML")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("IOY")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("IPG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("IPN")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("IRN")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("IT1")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("IU ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("IYR")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("IYT")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("IZO")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("JJJ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("JJK")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("JJL")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("JW5")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("K1R")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("KAG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("KCX")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("KGC")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("KNB")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("KOR")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("KPI")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("KST")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("KYQ")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("L2A")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LA2")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("LAA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("LAL")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LBY")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("LC ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("LCA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("LCC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("LCG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("LCH")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LCK")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LCX")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LDH")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LED")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEF")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEH")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("LEI")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEM")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("LET")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEU")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("LEX")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("LG ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("LGP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("LHC")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("LHU")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("LKC")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LLP")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LLY")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("LME")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LMF")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("LMQ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("LMS")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LP6")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("LPD")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("LPG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("LPL")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("LPS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("LSO")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("LTA")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("LTR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("LVG")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("LVN")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYF")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYK")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYM")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYN")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYR")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYS")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYX")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("LYZ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("M0H")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("M1G")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("M2G")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("M2L")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("M2S")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("M30")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("M3L")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("M5M")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MA ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MA6")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MA7")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MAA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MAD")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("MAI")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("MBQ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("MBZ")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("MC1")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MCG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("MCL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("MCS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("MCY")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("MD3")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MD6")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MDH")); + assertEquals("ASG", ResidueProperties.getCanonicalAminoAcid("MDO")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("MDR")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("MEA")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MED")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("MEG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("MEN")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("MEP")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("MEQ")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MET")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MEU")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MF3")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("MFC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MG1")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("MGG")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("MGN")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MGQ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MGV")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MGY")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("MHL")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MHO")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("MHS")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MIA")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("MIS")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("MK8")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("ML3")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("MLE")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("MLL")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("MLY")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("MLZ")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MME")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("MMO")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("MMT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("MND")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("MNL")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("MNU")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("MNV")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MOD")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("MP8")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MPH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MPJ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MPQ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MRG")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("MSA")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MSE")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MSL")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MSO")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("MSP")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("MT2")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("MTR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("MTU")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("MTY")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("MVA")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("N ")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("N10")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("N2C")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("N5I")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("N5M")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("N6G")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("N7P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("NA8")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("NAL")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("NAM")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("NB8")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("NBQ")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("NC1")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("NCB")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("NCX")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("NCY")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("NDF")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("NDN")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("NEM")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("NEP")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("NF2")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("NFA")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("NHL")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("NIT")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("NIY")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("NLE")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("NLN")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("NLO")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("NLP")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("NLQ")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("NMC")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("NMM")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("NMS")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("NMT")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("NNH")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("NP3")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("NPH")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("NPI")); + assertEquals("LYG", ResidueProperties.getCanonicalAminoAcid("NRP")); + assertEquals("MYG", ResidueProperties.getCanonicalAminoAcid("NRQ")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("NSK")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("NTY")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("NVA")); + assertEquals("TWG", ResidueProperties.getCanonicalAminoAcid("NYC")); + assertEquals("NYG", ResidueProperties.getCanonicalAminoAcid("NYG")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("NYM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("NYS")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("NZH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("O12")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("O2C")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("O2G")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("OAD")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("OAS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("OBF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("OBS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("OCS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("OCY")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ODP")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("OHI")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("OHS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("OIC")); + assertEquals("ILE", ResidueProperties.getCanonicalAminoAcid("OIP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("OLE")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("OLT")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("OLZ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("OMC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("OMG")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("OMT")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("OMU")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("ONE")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ONH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ONL")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("OPR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ORN")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("ORQ")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("OSE")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("OTB")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("OTH")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("OTY")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("OXX")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("P ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("P1L")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("P1P")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("P2T")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("P2U")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("P2Y")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("P5P")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("PAQ")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("PAS")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("PAT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PAU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PBB")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PBF")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("PBT")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("PCA")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("PCC")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PCE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PCS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PDL")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("PDU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PEC")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PF5")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PFF")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PFX")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("PG1")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PG7")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PG9")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PGL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PGN")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PGP")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PGY")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PHA")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("PHD")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PHE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PHI")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PHL")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PHM")); + assertEquals("AYG", ResidueProperties.getCanonicalAminoAcid("PIA")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PIV")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("PLE")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PM3")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PMT")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("POM")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PPN")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PPU")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("PPW")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("PQ1")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PR3")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PR5")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("PR9")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PRN")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("PRO")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("PRS")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("PSA")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("PSH")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("PST")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("PSU")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PSW")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PTA")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("PTH")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("PTM")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("PTR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PU ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("PUY")); + assertEquals("HIS", ResidueProperties.getCanonicalAminoAcid("PVH")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("PVL")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("PYA")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("PYO")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("PYX")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("PYY")); + assertEquals("QLG", ResidueProperties.getCanonicalAminoAcid("QLG")); + assertEquals("GLN", ResidueProperties.getCanonicalAminoAcid("QMM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("QPA")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("QPH")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("QUO")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("R ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("R1A")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("R4K")); + assertEquals("HYG", ResidueProperties.getCanonicalAminoAcid("RC7")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("RE0")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("RE3")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("RIA")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("RMP")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("RON")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("RT ")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("RTP")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("S1H")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("S2C")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("S2D")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("S2M")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("S2P")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("S4A")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("S4C")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("S4G")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("S4U")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("S6G")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SAC")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SAH")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("SAR")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SBL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SC ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SCH")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SCS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SCY")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("SD2")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("SDG")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SDP")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SEB")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("SEC")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("SEG")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SEL")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SEM")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SEN")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SEP")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SER")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SET")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SGB")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SHC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("SHP")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("SHR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SIB")); + assertEquals("DC", ResidueProperties.getCanonicalAminoAcid("SIC")); // check + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("SLA")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("SLR")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("SLZ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SMC")); + assertEquals("MET", ResidueProperties.getCanonicalAminoAcid("SME")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("SMF")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("SMP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("SMT")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SNC")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("SNN")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SOC")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("SOS")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SOY")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("SPT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("SRA")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("SSU")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("STY")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("SUB")); + assertEquals("DG", ResidueProperties.getCanonicalAminoAcid("SUI")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SUN")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("SUR")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SVA")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SVV")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SVW")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SVX")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("SVY")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("SVZ")); + assertEquals("SWG", ResidueProperties.getCanonicalAminoAcid("SWG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("SYS")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T ")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("T11")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T23")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T2S")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("T2T")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("T31")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T32")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T36")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T37")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T38")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T39")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T3P")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T41")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T48")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T49")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T4S")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("T5O")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("T5S")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("T66")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("T6A")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TA3")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TA4")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TAF")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("TAL")); + assertEquals("ASP", ResidueProperties.getCanonicalAminoAcid("TAV")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("TBG")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TBM")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("TC1")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TCP")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TCQ")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TCR")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("TCY")); + assertEquals("LEU", ResidueProperties.getCanonicalAminoAcid("TDD")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TDY")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TFE")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("TFO")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("TFQ")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TFT")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("TGP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TH6")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("THC")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("THO")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("THR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("THX")); + assertEquals("ARG", ResidueProperties.getCanonicalAminoAcid("THZ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("TIH")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("TLB")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TLC")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("TLN")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TMB")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TMD")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("TNB")); + assertEquals("SER", ResidueProperties.getCanonicalAminoAcid("TNR")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TOX")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TP1")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("TPC")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("TPG")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TPH")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TPL")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TPO")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TPQ")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TQI")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TQQ")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRF")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("TRG")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRN")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRO")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRP")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRQ")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRW")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TRX")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("TS ")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TST")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("TT ")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TTD")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("TTI")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("TTM")); + assertEquals("TRP", ResidueProperties.getCanonicalAminoAcid("TTQ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TTS")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TY1")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TY2")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TY3")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TY5")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYB")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYI")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYJ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYN")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYO")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYQ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYR")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYS")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYT")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("TYU")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYW")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TYX")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("TYY")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TZB")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("TZO")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U ")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U25")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U2L")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U2N")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U2P")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U31")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U33")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U34")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U36")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U37")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("U8U")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UAR")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UCL")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UD5")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("UDP")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("UFP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UFR")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UFT")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("UMA")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UMP")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UMS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("UN1")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("UN2")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("UNK")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("UR3")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("URD")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("US1")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("US2")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("US3")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("US5")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("USM")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("VAD")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("VAF")); + assertEquals("VAL", ResidueProperties.getCanonicalAminoAcid("VAL")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("VB1")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("VDL")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("VLL")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("VLM")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("VMS")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("VOL")); + assertEquals("GYG", ResidueProperties.getCanonicalAminoAcid("WCR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("X ")); + assertEquals("GLU", ResidueProperties.getCanonicalAminoAcid("X2W")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("X4A")); + assertEquals("AFG", ResidueProperties.getCanonicalAminoAcid("X9Q")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("XAD")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XAE")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("XAL")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XAR")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("XCL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("XCN")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("XCP")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("XCR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XCS")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("XCT")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("XCY")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XGA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("XGL")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("XGR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("XGU")); + assertEquals("PRO", ResidueProperties.getCanonicalAminoAcid("XPR")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XSN")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("XTH")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("XTL")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("XTR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("XTS")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("XTY")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("XUA")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("XUG")); + assertEquals("LYS", ResidueProperties.getCanonicalAminoAcid("XX1")); + assertEquals("THG", ResidueProperties.getCanonicalAminoAcid("XXY")); + assertEquals("DYG", ResidueProperties.getCanonicalAminoAcid("XYG")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("Y ")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("YCM")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("YG ")); + assertEquals("TYR", ResidueProperties.getCanonicalAminoAcid("YOF")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("YRR")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("YYG")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("Z ")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("Z01")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ZAD")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ZAL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("ZBC")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("ZBU")); + assertEquals("PHE", ResidueProperties.getCanonicalAminoAcid("ZCL")); + assertEquals("CYS", ResidueProperties.getCanonicalAminoAcid("ZCY")); + assertEquals("UR3", ResidueProperties.getCanonicalAminoAcid("ZDU")); + assertEquals("XAA", ResidueProperties.getCanonicalAminoAcid("ZFB")); + assertEquals("GLY", ResidueProperties.getCanonicalAminoAcid("ZGU")); + assertEquals("ASN", ResidueProperties.getCanonicalAminoAcid("ZHP")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ZTH")); + assertEquals("THR", ResidueProperties.getCanonicalAminoAcid("ZU0")); + assertEquals("ALA", ResidueProperties.getCanonicalAminoAcid("ZZJ")); + assertEquals(null, ResidueProperties.getCanonicalAminoAcid(null)); } -- 1.7.10.2