raspberry-sailor/NMEA-Parser/notebooks/HowItWorks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0783d5e6",
   "metadata": {},
   "source": [
    "# Basics: how NMEA Parsers work, with example, in Java."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df82e4e3",
   "metadata": {},
   "source": [
    "All NMEA Strings are made out of several parts:\n",
    "- A '$' sign\n",
    "- A Device (aka talker) ID\n",
    "- A Sentence ID\n",
    "- The Sentence data\n",
    "- A Checksum, preceded with a star\n",
    "- A String terminator, usually CR-LF (Carriage Return, and Line Feed)\n",
    "\n",
    "Example, RMC String:\n",
    "```\n",
    " $GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W,T*6A\n",
    " || |   |                                                            |\n",
    " || |   |                                                            Checksum, 6A\n",
    " || |   Data, comma-separated, 123519,...,T\n",
    " || Sentence ID, RMC\n",
    " |Talker ID, GP\n",
    " Dollar sign\n",
    "```\n",
    "\n",
    "\n",
    "The Data, per the NMEA Spec:\n",
    "\n",
    "```\n",
    "                                                                  12\n",
    "       1      2 3        4 5         6 7     8     9      10    11\n",
    "$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W,T*6A\n",
    "       |      | |        | |         | |     |     |      |     | |\n",
    "       |      | |        | |         | |     |     |      |     | Type\n",
    "       |      | |        | |         | |     |     |      |     Variation sign\n",
    "       |      | |        | |         | |     |     |      Variation value\n",
    "       |      | |        | |         | |     |     Date DDMMYY\n",
    "       |      | |        | |         | |     COG\n",
    "       |      | |        | |         | SOG\n",
    "       |      | |        | |         Longitude Sign\n",
    "       |      | |        | Longitude Value\n",
    "       |      | |        Latitude Sign\n",
    "       |      | Latitude value\n",
    "       |      Active or Void\n",
    "       UTC\n",
    "\n",
    "```\n",
    "The Sentence IDs, and their corresponding content and structure are defined by the NMEA specification."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed247a44",
   "metadata": {},
   "source": [
    "## The checksum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "011501a4",
   "metadata": {},
   "source": [
    "The first thing to do is to validate the checksum; this will tell you if the sentence is valid, and is worth parsing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e71acf69",
   "metadata": {},
   "source": [
    "The checksum validation concerns the part of the string _after_ the `$` sign, and _before_ the `*`.  \n",
    "In the above, this would be `GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W,T`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bdbf284",
   "metadata": {},
   "source": [
    "The checksum is the HexaDecimal value of the XOR (aka eXclusive OR) value of each byte of the string to validate."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd33121f",
   "metadata": {},
   "source": [
    "Here is a Java example of such an operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f491f3b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W\n",
      "...Checksum is now 0x17 \n",
      "...Checksum is now 0x45 \n",
      "...Checksum is now 0x08 \n",
      "...Checksum is now 0x4B \n",
      "...Checksum is now 0x67 \n",
      "...Checksum is now 0x56 \n",
      "...Checksum is now 0x64 \n",
      "...Checksum is now 0x57 \n",
      "...Checksum is now 0x62 \n",
      "...Checksum is now 0x53 \n",
      "...Checksum is now 0x6A \n",
      "...Checksum is now 0x46 \n",
      "...Checksum is now 0x07 \n",
      "...Checksum is now 0x2B \n",
      "...Checksum is now 0x1F \n",
      "...Checksum is now 0x27 \n",
      "...Checksum is now 0x17 \n",
      "...Checksum is now 0x20 \n",
      "...Checksum is now 0x0E \n",
      "...Checksum is now 0x3E \n",
      "...Checksum is now 0x0D \n",
      "...Checksum is now 0x35 \n",
      "...Checksum is now 0x19 \n",
      "...Checksum is now 0x57 \n",
      "...Checksum is now 0x7B \n",
      "...Checksum is now 0x4B \n",
      "...Checksum is now 0x7A \n",
      "...Checksum is now 0x4B \n",
      "...Checksum is now 0x78 \n",
      "...Checksum is now 0x49 \n",
      "...Checksum is now 0x67 \n",
      "...Checksum is now 0x57 \n",
      "...Checksum is now 0x67 \n",
      "...Checksum is now 0x57 \n",
      "...Checksum is now 0x7B \n",
      "...Checksum is now 0x3E \n",
      "...Checksum is now 0x12 \n",
      "...Checksum is now 0x22 \n",
      "...Checksum is now 0x10 \n",
      "...Checksum is now 0x22 \n",
      "...Checksum is now 0x0C \n",
      "...Checksum is now 0x38 \n",
      "...Checksum is now 0x14 \n",
      "...Checksum is now 0x24 \n",
      "...Checksum is now 0x1C \n",
      "...Checksum is now 0x28 \n",
      "...Checksum is now 0x06 \n",
      "...Checksum is now 0x32 \n",
      "...Checksum is now 0x1E \n",
      "...Checksum is now 0x2C \n",
      "...Checksum is now 0x1F \n",
      "...Checksum is now 0x2F \n",
      "...Checksum is now 0x1C \n",
      "...Checksum is now 0x25 \n",
      "...Checksum is now 0x11 \n",
      "...Checksum is now 0x3D \n",
      "...Checksum is now 0x0D \n",
      "...Checksum is now 0x3D \n",
      "...Checksum is now 0x0E \n",
      "...Checksum is now 0x20 \n",
      "...Checksum is now 0x11 \n",
      "...Checksum is now 0x3D \n",
      "...Checksum is now 0x6A \n",
      "Final Checksum 0x6A (decimal 106)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@395716dc"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String nmeaSentence = \"$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A\\r\\n\"; // No Type here\n",
    "String str = nmeaSentence.substring(1, nmeaSentence.indexOf(\"*\")); // Assume there IS a star\n",
    "System.out.printf(\"Validating %s\\n\", str);\n",
    "\n",
    "int cs = 0;\n",
    "char[] ca = str.toCharArray();\n",
    "cs = ca[0];\n",
    "for (int i = 1; i < ca.length; i++) {\n",
    "  cs = cs ^ ca[i]; // XOR\n",
    "  System.out.printf(\"...Checksum is now 0x%02X \\n\", cs);\n",
    "}\n",
    "System.out.printf(\"Final Checksum 0x%02X (decimal %d)\\n\", cs, cs);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04f68f6b",
   "metadata": {},
   "source": [
    "If the calculated checksum is the same as the one provided in the string itself, then the string is valid. We are looking for a `6A` here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaa525dc",
   "metadata": {},
   "source": [
    "The string happens here to be valid, we can proceed to parsing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "174492d4",
   "metadata": {},
   "source": [
    "Let's split the data into an array of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c5a16183",
   "metadata": {},
   "outputs": [],
   "source": [
    "String[] data = str.split(\",\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d797cad4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPRMC\n",
      "123519\n",
      "A\n",
      "4807.038\n",
      "N\n",
      "01131.000\n",
      "E\n",
      "022.4\n",
      "084.4\n",
      "230394\n",
      "003.1\n",
      "W\n"
     ]
    }
   ],
   "source": [
    "Arrays.asList(data).forEach(System.out::println);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aefd69d",
   "metadata": {},
   "source": [
    "Then, the NMEA spec tells us what element corresponds to what data (starting with index 1).  Look [here](https://gpsd.gitlab.io/gpsd/NMEA.html#_rmc_recommended_minimum_navigation_information) for RMC structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eee800a",
   "metadata": {},
   "source": [
    "Let's try to parse a `RMC` sentence.  \n",
    "We can give a name to each element of the data array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cb124390",
   "metadata": {},
   "outputs": [],
   "source": [
    "final int RMC_UTC = 1;\n",
    "final int RMC_ACTIVE_VOID = 2;\n",
    "final int RMC_LATITUDE_VALUE = 3;\n",
    "final int RMC_LATITUDE_SIGN = 4;\n",
    "final int RMC_LONGITUDE_VALUE = 5;\n",
    "final int RMC_LONGITUDE_SIGN = 6;\n",
    "final int RMC_SOG = 7;\n",
    "final int RMC_COG = 8;\n",
    "final int RMC_DDMMYY = 9;\n",
    "final int RMC_VARIATION_VALUE = 10;\n",
    "final int RMC_VARIATION_SIGN = 11;\n",
    "final int RMC_TYPE = 12;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7904cf2",
   "metadata": {},
   "source": [
    "We create static methods to process the checksum, and others..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d3867eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "static int calculateCheckSum(String str) {\n",
    "    int cs = 0;\n",
    "    char[] ca = str.toCharArray();\n",
    "    cs = ca[0];\n",
    "    for (int i = 1; i < ca.length; i++) {\n",
    "        cs = cs ^ ca[i]; // XOR\n",
    "    }\n",
    "    return cs;\n",
    "}\n",
    "\n",
    "static boolean validCheckSum(String data) {\n",
    "    String sentence = data.trim();\n",
    "    boolean b = false;\n",
    "    try {\n",
    "        int starIndex = sentence.indexOf(\"*\");\n",
    "        if (starIndex < 0) {\n",
    "            return false;\n",
    "        }\n",
    "        String csKey = sentence.substring(starIndex + 1);\n",
    "        int csk = Integer.parseInt(csKey, 16);\n",
    "        String str2validate = sentence.substring(1, sentence.indexOf(\"*\"));\n",
    "        int calcCheckSum = calculateCheckSum(str2validate);\n",
    "        b = (calcCheckSum == csk);\n",
    "    } catch (Exception ex) {\n",
    "        System.err.println(\"Oops:\" + ex.getMessage());\n",
    "    }\n",
    "    return b;\n",
    "}\n",
    "\n",
    "static double sexToDec(String degrees, String minutes) {\n",
    "    double ret;\n",
    "    try {\n",
    "        double deg = Double.parseDouble(degrees);\n",
    "        double min = Double.parseDouble(minutes);\n",
    "        min *= (10.0 / 6.0);\n",
    "        ret = deg + (min / 100D);\n",
    "    } catch (NumberFormatException nfe) {\n",
    "        nfe.printStackTrace();\n",
    "        System.err.println(\"Degrees:\" + degrees);\n",
    "        System.err.println(\"Minutes:\" + minutes);\n",
    "        throw new RuntimeException(\"Bad number [\" + degrees + \"] [\" + minutes + \"]\");\n",
    "    }\n",
    "    return ret;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00924e80",
   "metadata": {},
   "source": [
    "Then we can define a class(es) to hold the parsed data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "86bdbea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.text.SimpleDateFormat;\n",
    "\n",
    "static class GeoPos {\n",
    "    double lat;\n",
    "    double lng;\n",
    "    public GeoPos(double l, double g) {\n",
    "        this.lat = l;\n",
    "        this.lng = g;\n",
    "    }\n",
    "}\n",
    "\n",
    "class RMC {\n",
    "    GeoPos gp = null;\n",
    "    double sog = -1D;\n",
    "    double cog = -1D;\n",
    "\n",
    "    boolean valid = false; // False means warning.\n",
    "\n",
    "    Date rmcDate = null;\n",
    "    Date rmcTime = null;\n",
    "    double declination = -Double.MAX_VALUE;\n",
    "    \n",
    "    public enum RMC_TYPE {\n",
    "        AUTONOMOUS,\n",
    "        DIFFERENTIAL,\n",
    "        ESTIMATED,\n",
    "        NOT_VALID,\n",
    "        SIMULATOR\n",
    "    }\n",
    "\n",
    "    RMC_TYPE rmcType = null;\n",
    "\n",
    "    final static SimpleDateFormat SDF = new SimpleDateFormat(\"E dd-MMM-yyyy HH:mm:ss.SS\");\n",
    "    static {\n",
    "        SDF.setTimeZone(TimeZone.getTimeZone(\"Etc/UTC\"));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40ea7fba",
   "metadata": {},
   "source": [
    "And we can start parsing. We write a static method for this operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8fe218b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.text.NumberFormat;\n",
    "import java.util.Calendar;\n",
    "import java.util.Date;\n",
    "import java.util.Locale;\n",
    "import java.util.TimeZone;\n",
    "\n",
    "final static NumberFormat NF = NumberFormat.getInstance(Locale.ENGLISH);\n",
    "\n",
    "static RMC parseRMC(String str) {\n",
    "    RMC rmc = null;\n",
    "    if (str.length() < 6 || !str.contains(\"*\")) {\n",
    "        return null;\n",
    "    }\n",
    "    if (!validCheckSum(str)) {\n",
    "        return null;\n",
    "    }\n",
    "    String s = str.substring(0, str.indexOf(\"*\"));\n",
    "    try {\n",
    "        if (s.contains(\"RMC,\")) {\n",
    "            rmc = new RMC();\n",
    "\n",
    "            String[] data = s.split(\",\");\n",
    "            rmc.valid = (data[RMC_ACTIVE_VOID].equals(\"A\")); // Active. Does not prevent the date and time from being available.\n",
    "            if (data[RMC_UTC].length() > 0) { // Time and Date\n",
    "                double utc = 0D;\n",
    "                try {\n",
    "                    utc = NF.parse(data[RMC_UTC]).doubleValue();\n",
    "                } catch (Exception ex) {\n",
    "                    System.out.println(\"data[1] in StringParsers.parseRMC\");\n",
    "                }\n",
    "                int h = (int) (utc / 10_000);\n",
    "                int m = (int) ((utc - (10_000 * h)) / 100);\n",
    "                float sec = (float) (utc % 100f);\n",
    "\n",
    "                // System.out.println(\"Data[1]:\" + data[1] + \", h:\" + h + \", m:\" + m + \", s:\" + sec);\n",
    "\n",
    "                Calendar local = Calendar.getInstance(TimeZone.getTimeZone(\"Etc/UTC\"));\n",
    "                local.set(Calendar.HOUR_OF_DAY, h);\n",
    "                local.set(Calendar.MINUTE, m);\n",
    "                local.set(Calendar.SECOND, (int) Math.round(sec));\n",
    "                local.set(Calendar.MILLISECOND, 0);\n",
    "                if (data[RMC_DDMMYY].length() > 0) {\n",
    "                    int d = 1;\n",
    "                    try {\n",
    "                        d = Integer.parseInt(data[RMC_DDMMYY].substring(0, 2));\n",
    "                    } catch (Exception ex) {\n",
    "                        ex.printStackTrace();\n",
    "                    }\n",
    "                    int mo = 0;\n",
    "                    try {\n",
    "                        mo = Integer.parseInt(data[RMC_DDMMYY].substring(2, 4)) - 1;\n",
    "                    } catch (Exception ex) {\n",
    "                        ex.printStackTrace();\n",
    "                    }\n",
    "                    int y = 0;\n",
    "                    try {\n",
    "                        y = Integer.parseInt(data[RMC_DDMMYY].substring(4));\n",
    "                    } catch (Exception ex) {\n",
    "                        ex.printStackTrace();\n",
    "                    }\n",
    "                    if (y > 50) {\n",
    "                        y += 1900;\n",
    "                    } else {\n",
    "                        y += 2_000;\n",
    "                    }\n",
    "                    local.set(Calendar.DATE, d);\n",
    "                    local.set(Calendar.MONTH, mo);\n",
    "                    local.set(Calendar.YEAR, y);\n",
    "                    Date rmcDate = local.getTime();\n",
    "                    rmc.rmcDate = rmcDate;\n",
    "                }\n",
    "                Date rmcTime = local.getTime();\n",
    "                rmc.rmcTime = rmcTime;\n",
    "            }\n",
    "            if (data[RMC_LATITUDE_VALUE].length() > 0 && data[RMC_LONGITUDE_VALUE].length() > 0) {\n",
    "                String deg = data[RMC_LATITUDE_VALUE].substring(0, 2);\n",
    "                String min = data[RMC_LATITUDE_VALUE].substring(2);\n",
    "                double l = sexToDec(deg, min);\n",
    "                if (\"S\".equals(data[RMC_LATITUDE_SIGN])) {\n",
    "                    l = -l;\n",
    "                }\n",
    "                deg = data[RMC_LONGITUDE_VALUE].substring(0, 3);\n",
    "                min = data[RMC_LONGITUDE_VALUE].substring(3);\n",
    "                double g = sexToDec(deg, min);\n",
    "                if (\"W\".equals(data[RMC_LONGITUDE_SIGN])) {\n",
    "                    g = -g;\n",
    "                }\n",
    "                rmc.gp = new GeoPos(l, g);\n",
    "            }\n",
    "            if (data[RMC_SOG].length() > 0) {\n",
    "                double speed = 0;\n",
    "                try {\n",
    "                    speed = NF.parse(data[RMC_SOG]).doubleValue();\n",
    "                } catch (Exception ex) {\n",
    "                    ex.printStackTrace();\n",
    "                }\n",
    "                rmc.sog = speed;\n",
    "            }\n",
    "            if (data[RMC_COG].length() > 0) {\n",
    "                double cog = 0;\n",
    "                try {\n",
    "                    cog = NF.parse(data[RMC_COG]).doubleValue();\n",
    "                } catch (Exception ex) {\n",
    "                    ex.printStackTrace();\n",
    "                }\n",
    "                rmc.cog = cog;\n",
    "            }\n",
    "            if (data[RMC_VARIATION_VALUE].length() > 0 && data[RMC_VARIATION_SIGN].length() > 0) {\n",
    "                double d = -Double.MAX_VALUE;\n",
    "                try {\n",
    "                    d = NF.parse(data[RMC_VARIATION_VALUE]).doubleValue();\n",
    "                } catch (Exception ex) {\n",
    "                    ex.printStackTrace();\n",
    "                }\n",
    "                if (\"W\".equals(data[RMC_VARIATION_SIGN])) {\n",
    "                    d = -d;\n",
    "                }\n",
    "                rmc.declination = d;\n",
    "            }\n",
    "            if (data.length > 12) { // Can be missing\n",
    "                switch (data[RMC_TYPE]) {\n",
    "                    case \"A\":\n",
    "                        rmc.rmcType = RMC.RMC_TYPE.AUTONOMOUS;\n",
    "                        break;\n",
    "                    case \"D\":\n",
    "                        rmc.rmcType = RMC.RMC_TYPE.DIFFERENTIAL;\n",
    "                        break;\n",
    "                    case \"E\":\n",
    "                        rmc.rmcType = RMC.RMC_TYPE.ESTIMATED;\n",
    "                        break;\n",
    "                    case \"N\":\n",
    "                        rmc.rmcType = RMC.RMC_TYPE.NOT_VALID;\n",
    "                        break;\n",
    "                    case \"S\":\n",
    "                        rmc.rmcType = RMC.RMC_TYPE.SIMULATOR;\n",
    "                        break;\n",
    "                    default:\n",
    "                        rmc.rmcType = null;\n",
    "                        break;\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    } catch (Exception e) {\n",
    "        System.err.println(\"In parseRMC for \" + str.trim() + \", \" + e.toString());\n",
    "        e.printStackTrace();\n",
    "    }\n",
    "    return rmc;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c7a0e19",
   "metadata": {},
   "source": [
    "We're now good to start parsing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de885c46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parsing $GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A\n",
      "\n",
      "Valid:\ttrue\n",
      "Lat:\t48.1173\n",
      "Lng:\t11.516666666666667\n",
      "Speed over Ground:\t22.4\n",
      "Course over Ground:\t84.4\n",
      "UTC Date:\tWed 23-Mar-1994 12:35:19.00\n",
      "UTC Time:\tWed 23-Mar-1994 12:35:19.00\n",
      "Declination:\t-3.1\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Parsing \" + nmeaSentence);\n",
    "\n",
    "RMC rmc = parseRMC(nmeaSentence);\n",
    "\n",
    "// Display members\n",
    "System.out.println(\"Valid:\\t\" + rmc.valid);\n",
    "System.out.println(\"Lat:\\t\" + rmc.gp.lat);\n",
    "System.out.println(\"Lng:\\t\" + rmc.gp.lng);\n",
    "System.out.println(\"Speed over Ground:\\t\" + rmc.sog);\n",
    "System.out.println(\"Course over Ground:\\t\" + rmc.cog);\n",
    "\n",
    "System.out.println(\"UTC Date:\\t\" + RMC.SDF.format(rmc.rmcDate));\n",
    "System.out.println(\"UTC Time:\\t\" + RMC.SDF.format(rmc.rmcTime));\n",
    "\n",
    "System.out.println(\"Declination:\\t\" + rmc.declination);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60d0ae6a",
   "metadata": {},
   "source": [
    "**_Important Warning_**: The data are comma-separated, and for the numbers, the decimal separator is `.`. When parsing the data, do make sure the `Locale` is set correctly. For example, if the `Locale` is set to `fr_FR`, the decimal separator will be `,`... which can indeed lead to unexpected results. See in the code above how this is used, the number format named `NF`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "56f62af5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User Locale: en_US\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@395716dc"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"User Locale: %s_%s\\n\", System.getProperty(\"user.language\"), System.getProperty(\"user.country\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4fb06d5",
   "metadata": {},
   "source": [
    "Good luck!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "11.0.8+10-LTS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}