notebooks/gpt_model_prep_v3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GenAI model tuning prep data\n",
    "\n",
    "This notebook attempts to transform free form data to JSONL format so it can be used by OpenAI model tuning API.\n",
    "\n",
    "* 20231125 Using try3 data and the context rule hardcoded\n",
    "* 20231118 first set of train and test code.\n",
    "* 20231116 Second set of actual asm code.\n",
    "* 20231109 Uses first set of actual asm code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import pathlib\n",
    "import json\n",
    "\n",
    "import pandas as pd\n",
    "import os\n",
    "import os.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup dirs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20231125'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the current date\n",
    "current_date = datetime.datetime.now()\n",
    "\n",
    "# Format the date as YYYYMMDD\n",
    "formatted_date = current_date.strftime('%Y%m%d')\n",
    "formatted_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OUT_TRAIN_FILE_NAME:  train20231125.jsonl\n",
      "OUT_TEST_FILE_NAME:  test20231125.jsonl\n"
     ]
    }
   ],
   "source": [
    "# This can be varied to point to different files.\n",
    "OUT_TRAIN_FILE_NAME = 'train' + formatted_date + '.jsonl'\n",
    "OUT_TEST_FILE_NAME = 'test' + formatted_date + '.jsonl'\n",
    "os.environ['OUT_TRAIN_FILE_NAME'] = OUT_TRAIN_FILE_NAME\n",
    "os.environ['OUT_TEST_FILE_NAME'] = OUT_TEST_FILE_NAME\n",
    "print(\"OUT_TRAIN_FILE_NAME: \", OUT_TRAIN_FILE_NAME)\n",
    "print(\"OUT_TEST_FILE_NAME: \", OUT_TEST_FILE_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current directory is : /workspaces/BALSA/notebooks\n"
     ]
    }
   ],
   "source": [
    "# The current directory will be where this src file is located.\n",
    "# Which is in the notebooks dir of the project\n",
    "dirpath = os.getcwd()\n",
    "print(\"current directory is : \" + dirpath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root directory is:  /workspaces/BALSA\n",
      "data directory is:  /workspaces/BALSA/data\n",
      "train directory is:  /workspaces/BALSA/data/try3/train\n",
      "test directory is:  /workspaces/BALSA/data/try3/test\n"
     ]
    }
   ],
   "source": [
    "# Use pathlib to find the root dir of the git repo\n",
    "root_path = pathlib.PurePath(dirpath).parents[0]\n",
    "data_path = root_path / 'data'\n",
    "train_path = data_path / 'try3' / 'train'\n",
    "test_path = data_path / 'try3' / 'test'\n",
    "print(\"root directory is: \", root_path)\n",
    "print(\"data directory is: \",  data_path)\n",
    "print(\"train directory is: \",  train_path)\n",
    "print(\"test directory is: \", test_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DATA_DIR_NAME:  /workspaces/BALSA/data\n"
     ]
    }
   ],
   "source": [
    "# Create equivalent dir names in the environment\n",
    "# Data\n",
    "DATA_DIR_NAME = data_path.as_posix()\n",
    "print(\"DATA_DIR_NAME: \", DATA_DIR_NAME)\n",
    "os.environ['DATA_DIR_NAME'] = DATA_DIR_NAME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/workspaces/BALSA/data\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "# Verify env variables are set\n",
    "echo ${DATA_DIR_NAME}\n",
    "echo ${LOGS_DIR_NAME}\n",
    "echo ${CSV_FILE_NAME}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Routine to build our tuning jsonl file from txt files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to read the input text file and convert it to JSONL format\n",
    "def convert_text_to_jsonl(input_file, output_file):\n",
    "    lines = []\n",
    "    messages = []\n",
    "    # stub vars\n",
    "    sample_code = []\n",
    "    commentary = []\n",
    "    prompt = []\n",
    "\n",
    "    with open(input_file, 'r') as file:\n",
    "        lines = file.readlines()\n",
    "\n",
    "\n",
    "    # \n",
    "    # find delimiters\n",
    "    #\n",
    "\n",
    "    posn = []\n",
    "    line_nbr = 0\n",
    "    for a_line in lines:\n",
    "        #print(a_line)\n",
    "        if (a_line == \"RESULT\\n\"):\n",
    "            #print(a_line, \" \", line_nbr )\n",
    "            # save that position\n",
    "            posn.append(line_nbr) \n",
    "        if (a_line == \"PROMPT\\n\"):\n",
    "            #print(a_line)\n",
    "            posn.append(line_nbr) \n",
    "        \n",
    "        line_nbr = line_nbr + 1\n",
    "\n",
    "    # Record the last line in file\n",
    "    posn.append(line_nbr) \n",
    "\n",
    "    #print(\"posn: \", posn)\n",
    "\n",
    "    # separate out the parts\n",
    "    result_lines = lines[1+1:posn[1]]\n",
    "    prompt_lines = lines[posn[1]+1:posn[2]]\n",
    "\n",
    "    # dump the parts\n",
    "    #print(\"===result_lines:===\\n\", result_lines)\n",
    "    #print(\"===prompt_lines:===\\n\", prompt_lines)\n",
    "\n",
    "    hardcoded_context=\"\"\"\n",
    "    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\n",
    "\n",
    "    When writing code, always obey these rules:\n",
    "\n",
    "* NAME corresponds to a LABEL and is always in column 1.\n",
    "    - The NAME is at most 8 characters long.\n",
    "    - The NAME begins with characters A-Z, a-z, $, # or @. \n",
    "* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\n",
    "* OPERANDS corresponds to an instruction argumennts or parameters.\n",
    "    - Multiple operands are separated by a comma `,`.\n",
    "    - Space ` ` characters are not permitted between OPERANDS.\n",
    "* COMMENT a comment has two starting locations.  \n",
    "    - If the entire line is a comment, then the comment marker `*` starts in column 1.\n",
    "    - If the comment is used at the end of a line of code, it starts at column 32.\n",
    "* Column 72 is used to identify a continuation of the current line to the next\n",
    "    - In this case, use a `x` in column 72 on the first line.\n",
    "    - On the second continued line, code starts at column 16.\n",
    "\n",
    "All code should be output in markdown or preformatted text blocks like so:\n",
    "\n",
    "```\n",
    "code here\n",
    "```\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "    a_dict = {}\n",
    "    a_dict['messages'] = []\n",
    "    \n",
    "    a_dict['messages'].append({'role':'system',\n",
    "                              'content': hardcoded_context})\n",
    "    a_dict['messages'].append({'role':'user',\n",
    "                               'content': ' '.join(prompt_lines)})\n",
    "    a_dict['messages'].append({'role':'assistant',\n",
    "                               'content': ' '.join(result_lines)})\n",
    "\n",
    "\n",
    "    #print(a_dict)\n",
    "    #print(output_file)\n",
    "\n",
    "    # append to output file\n",
    "    # modify with w to write a new one\n",
    "    with open(output_file, 'a') as jsonl_file:\n",
    "        jsonl_file.write(json.dumps(a_dict) + '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "#train_files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# build train file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "removed\n"
     ]
    }
   ],
   "source": [
    "OUT_TRAIN_FQPN = train_path /  pathlib.Path(OUT_TRAIN_FILE_NAME).as_posix()\n",
    "#print(OUT_TRAIN_FQPN)\n",
    "\n",
    "# remove any existing output\n",
    "try:\n",
    "    os.remove(OUT_TRAIN_FQPN)\n",
    "    print(\"removed\")\n",
    "except OSError:\n",
    "    print(\"did not remove the existing training file.\")\n",
    "\n",
    "train_files = os.listdir(train_path)\n",
    "#print(train_files)\n",
    "\n",
    "for a_file in train_files:\n",
    "    #print(\"a file name: \", a_file)\n",
    "    IN_FQPN = train_path /  pathlib.PurePath(a_file).as_posix()\n",
    "    #print(IN_FQPN)\n",
    "    #print(OUT_TRAIN_FQPN)\n",
    "    convert_text_to_jsonl(IN_FQPN, OUT_TRAIN_FQPN)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# build test file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "did not remove the existing training file.\n"
     ]
    }
   ],
   "source": [
    "OUT_TEST_FQPN = test_path /  pathlib.Path(OUT_TEST_FILE_NAME).as_posix()\n",
    "#print(OUT_FQPN)\n",
    "\n",
    "# remove any existing output\n",
    "try:\n",
    "    os.remove(OUT_TEST_FQPN)\n",
    "    print(\"removed\")\n",
    "except OSError:\n",
    "    print(\"did not remove the existing training file.\")\n",
    "\n",
    "test_files = os.listdir(test_path)\n",
    "\n",
    "for a_file in test_files:\n",
    "    #print(\"a file name: \", a_file)\n",
    "    IN_FQPN = test_path /  pathlib.PurePath(a_file).as_posix()\n",
    "    #print(IN_FQPN)\n",
    "    convert_text_to_jsonl(IN_FQPN, OUT_TEST_FQPN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ['OUT_TRAIN_FQPN'] = OUT_TRAIN_FQPN.as_posix()\n",
    "os.environ['OUT_TEST_FQPN'] = OUT_TEST_FQPN.as_posix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to subtract two fullword registers using integers and store the result in memory with a field name of DIFF.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to add are already in registers R1 and R2.  \\n \\n R1 will contain the minuend.\\n \\n R2 will contain the subtrahend.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Do not show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          SR   R1,R2\\n          ST   R1,DIFF\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to add are already in registers R1 and R2.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n \\n          AR   R1,R2\\n          ST   R1,SUM \\n \\n \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary or comments.  Only include code.\\n \\n Assume the values to add are already in registers R1 and R2.\\n \\n Obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          AR   R1,R2\\n          ST   R1,SUM \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to subtract two fullword registers using integers and store the result in memory with a field name of DIFF.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to add are already in registers R1 and R2.  \\n \\n R1 will contain the minuend.\\n \\n R2 will contain the subtrahend.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n \\n          SR   R1,R2\\n          ST   R1,DIFF\\n \\n \\n \\n DIFF     DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to logical and two fullword registers and store the result in memory with a field name of ANS.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to logical and are already in registers R1 and R2.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          NR   R1,R2\\n          ST   R1,ANS \\n \\n \\n \\n ANS      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to logical and two fullword registers and store the result in memory with a field name of ANS.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          NR   R1,R2\\n          ST   R1,ANS \\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Provide info on column usage when writing IBM BAL Assembly code.\\n \\n Your answer should be brief and in markdown format.  If you use preformated text blocks they\\n should be in this form:\\n \\n ```\\n put preformated text here\\n ```\\n \\n Use `*` to identify a comment.\\n \\n\"}, {\"role\": \"assistant\", \"content\": \"\\n This answer is using markdown format.\\n \\n This preformated text block shows the column usage for IBM BAL assembly.\\n The column headings are shown as a number ruler and hidden from the \\n assembler using comment character in first column as `*`.\\n \\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n ```\\n \\n * name starts at column 1\\n * operation starts at 10\\n * operands start at column 15\\n * comments which do not start in column 1, must start in column 32\\n * line continuation characters are placed in column 72\\n * line continuation characters are typically `x`\\n \\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to logical and two fullword registers and store the result in memory with a field name of ANS.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to logical and are already in registers R1 and R2.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n \\n          NR   R1,R2\\n          ST   R1,ANS \\n \\n \\n \\n ANS      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n How is memory organized in BAL?\\n\"}, {\"role\": \"assistant\", \"content\": \"Memory is organized as a sequence of bytes. Each byte is numbered and the number is called the byte address. \\n The first byte has number 0. The second byte has address 1, etc.\\n \\n This means that for the first word in memory, the first byte is address 0, the second byte is address 1. It \\n follows that the last byte in the second word in memory would be address 7.\\n \\n BAL memory is Big Endian so in terms of byte addresses it would look this to encode the 32 bit\\n hex number 0x01234567:\\n \\n ```\\n 00: 01\\n 01: 23\\n 02: 45\\n 02: 67\\n ```\\n \\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          AR   R1,R2\\n          ST   R1,SUM \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "head ${OUT_TRAIN_FQPN}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to add are already in registers R3 and R4.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n \\n          AR   R3,R4\\n          ST   R3,SUM \\n \\n \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary or comments.  Only include code.\\n \\n Assume the values to add are already in registers R3 and R4.\\n \\n Obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          AR   R3,R4\\n          ST   R3,SUM \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to logical and two fullword registers and store the result in memory with a field name of ANS.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to logical and are already in registers R7 and R8.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          NR   R7,R8\\n          ST   R7,ANS \\n \\n \\n \\n ANS      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to logical and two fullword registers and store the result in memory with a field name of ANS.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          NR   R5,R6\\n          ST   R5,ANS \\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Provide info on column usage when writing IBM BAL Assembly code.\\n \\n Your answer should be brief and in markdown format.  \\n\"}, {\"role\": \"assistant\", \"content\": \"\\n This answer is using markdown format.\\n \\n This preformated text block shows the column usage for IBM BAL assembly.\\n The column headings are shown as a number ruler and hidden from the \\n assembler using comment character in first column as `*`.\\n \\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts at column 1\\n *        operation starts at column 10\\n *             operands start at column 15\\n *                              comments start at column 32\\n *                                                                      continuation starts at column 72\\n ```\\n \\n * name starts at column 1\\n * operation starts at 10\\n * operands start at column 15\\n * comments which do not start in column 1, must start in column 32\\n * line continuation characters are placed in column 72\\n * line continuation characters are typically `x`\\n \\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Provide info on column usage when writing IBM BAL Assembly code.\\n \\n Your answer should be brief and in markdown format.  \\n\"}, {\"role\": \"assistant\", \"content\": \"\\n This answer is using markdown format.\\n \\n The column headings are shown as a number ruler and hidden from the \\n assembler using comment character in first column as `*`.\\n \\n ```\\n *        1         2         3         4         5         6         7         8 \\n *2345678901234567890123456789012345678901234567890123456789012345678901234567890\\n *name starts in column 1\\n *        operation starts in column 10\\n *             operands start in column 15\\n *                              comments start in column 32\\n *                                                                      continuation starts in column 72\\n ```\\n \\n * name starts in column 1\\n * operation starts in 10\\n * operands start in column 15\\n * comments which do not start in column 1, must start in column 32\\n * line continuation characters are placed in column 72\\n * line continuation characters are typically `x`\\n \\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          AR   R5,R4\\n          ST   R5,SUM \\n \\n SUM      DC   F'0'\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to subtract two fullword registers using integers and store the result in memory with a field name of DIFF.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          SR   R3,R4\\n          ST   R3,DIFF\\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to add two fullword registers and store the result in memory with a field name of SUM.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary or comments.  Only include code.\\n \\n Assume the values to add are already in registers R3 and R4.\\n \\n Obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Do not show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          AR   R3,R4\\n          ST   R3,SUM \\n \\n ```\\n \\n\"}]}\n",
      "{\"messages\": [{\"role\": \"system\", \"content\": \"\\n    you are a helpful assistant who understands IBM BAL (IBM Basic Assembler Language)\\n\\n    When writing code, always obey these rules:\\n\\n* NAME corresponds to a LABEL and is always in column 1.\\n    - The NAME is at most 8 characters long.\\n    - The NAME begins with characters A-Z, a-z, $, # or @. \\n* OPERATION corresponds to an instruction (mnemonic) and it starts in column 16.\\n* OPERANDS corresponds to an instruction argumennts or parameters.\\n    - Multiple operands are separated by a comma `,`.\\n    - Space ` ` characters are not permitted between OPERANDS.\\n* COMMENT a comment has two starting locations.  \\n    - If the entire line is a comment, then the comment marker `*` starts in column 1.\\n    - If the comment is used at the end of a line of code, it starts at column 32.\\n* Column 72 is used to identify a continuation of the current line to the next\\n    - In this case, use a `x` in column 72 on the first line.\\n    - On the second continued line, code starts at column 16.\\n\\nAll code should be output in markdown or preformatted text blocks like so:\\n\\n```\\ncode here\\n```\\n\"}, {\"role\": \"user\", \"content\": \"\\n Write some code in IBM BAL Assembly to subtract two fullword registers using integers and store the result in memory with a field name of DIFF.  \\n \\n Your answer should be brief and in markdown format using a code section using this format:\\n \\n ```\\n put code here\\n ```\\n \\n Do not include any commentary.  Just produce the code and comments.\\n \\n Assume the values to add are already in registers R3 and R4.  \\n \\n R1 will contain the minuend.\\n \\n R2 will contain the subtrahend.\\n \\n Use `*` to identify a comment and obey column restrictions for the code.\\n \\n Do not show any subroutine standard entry and exit code.\\n \\n Show how the field name should be declared.\"}, {\"role\": \"assistant\", \"content\": \"\\n ```\\n          SR   R3,R4\\n          ST   R3,DIFF\\n \\n \\n DIFF     DC   F'0'\\n ```\\n \\n\"}]}\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "head ${OUT_TEST_FQPN}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}