nodes: 0, module; 1, function_definition; 2, function_name:deleteByOrigIndexList; 3, parameters; 4, block; 5, identifier:self; 6, identifier:indexList; 7, expression_statement; 8, expression_statement; 9, expression_statement; 10, expression_statement; 11, for_statement; 12, expression_statement; 13, expression_statement; 14, return_statement; 15, comment:"""Remove entries from the list given the index references.
  
          The index, in this instance, is a reference to the *original* list
          indexing as seen when the list was first inserted into PLOD.
  
          An example:
  
          >>> test = [
          ...    {"name": "Jim",   "age": 18, "income": 93000, "wigs": 68       },
          ...    {"name": "Larry", "age": 18,                  "wigs": [3, 2, 9]},
          ...    {"name": "Joe",   "age": 20, "income": 15000, "wigs": [1, 2, 3]},
          ...    {"name": "Bill",  "age": 19, "income": 29000                   },
          ... ]
          >>> myPLOD = PLOD(test)
          >>> print myPLOD.sort("name").returnString()
          [
              {age: 19, income: 29000, name: 'Bill' , wigs: None     },
              {age: 18, income: 93000, name: 'Jim'  , wigs:        68},
              {age: 20, income: 15000, name: 'Joe'  , wigs: [1, 2, 3]},
              {age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
          ]
          >>> listA = [0, 1]
          >>> print myPLOD.deleteByOrigIndexList(listA).returnString()
          [
              {age: 20, income: 15000, name: 'Joe'  , wigs: [1, 2, 3]},
              {age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
          ]
  
          As you can see in the example, the list was sorted by 'name', which
          rearranged the entries. Yet, when the deleteByOrigIndexList was
          passed a [0, 1] (for the first and second entries), it removed 'Jim'
          and "Larry" since those were the original first and second entries.
  
          :param indexList:
             A list of integer representing the places of entry in the original
             list of dictionaries.
          :return:
             self
          """; 16, assignment; 17, assignment; 18, assignment; 19, identifier:row; 20, attribute; 21, block; 22, assignment; 23, assignment; 24, identifier:self; 25, identifier:result; 26, list; 27, identifier:result_tracker; 28, list; 29, identifier:counter; 30, integer:0; 31, identifier:self; 32, identifier:table; 33, if_statement; 34, expression_statement; 35, attribute; 36, identifier:result; 37, attribute; 38, identifier:result_tracker; 39, not_operator; 40, block; 41, augmented_assignment; 42, identifier:self; 43, identifier:table; 44, identifier:self; 45, identifier:index_track; 46, comparison_operator:counter in indexList; 47, expression_statement; 48, expression_statement; 49, identifier:counter; 50, integer:1; 51, identifier:counter; 52, identifier:indexList; 53, call; 54, call; 55, attribute; 56, argument_list; 57, attribute; 58, argument_list; 59, identifier:result; 60, identifier:append; 61, identifier:row; 62, identifier:result_tracker; 63, identifier:append; 64, subscript; 65, attribute; 66, identifier:counter; 67, identifier:self; 68, identifier:index_track
code: def deleteByOrigIndexList(self, indexList):
          """Remove entries from the list given the index references.
  
          The index, in this instance, is a reference to the *original* list
          indexing as seen when the list was first inserted into PLOD.
  
          An example:
  
          >>> test = [
          ...    {"name": "Jim",   "age": 18, "income": 93000, "wigs": 68       },
          ...    {"name": "Larry", "age": 18,                  "wigs": [3, 2, 9]},
          ...    {"name": "Joe",   "age": 20, "income": 15000, "wigs": [1, 2, 3]},
          ...    {"name": "Bill",  "age": 19, "income": 29000                   },
          ... ]
          >>> myPLOD = PLOD(test)
          >>> print myPLOD.sort("name").returnString()
          [
              {age: 19, income: 29000, name: 'Bill' , wigs: None     },
              {age: 18, income: 93000, name: 'Jim'  , wigs:        68},
              {age: 20, income: 15000, name: 'Joe'  , wigs: [1, 2, 3]},
              {age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
          ]
          >>> listA = [0, 1]
          >>> print myPLOD.deleteByOrigIndexList(listA).returnString()
          [
              {age: 20, income: 15000, name: 'Joe'  , wigs: [1, 2, 3]},
              {age: 18, income: None , name: 'Larry', wigs: [3, 2, 9]}
          ]
  
          As you can see in the example, the list was sorted by 'name', which
          rearranged the entries. Yet, when the deleteByOrigIndexList was
          passed a [0, 1] (for the first and second entries), it removed 'Jim'
          and "Larry" since those were the original first and second entries.
  
          :param indexList:
             A list of integer representing the places of entry in the original
             list of dictionaries.
          :return:
             self
          """
          result = []
          result_tracker = []
          counter = 0
          for row in self.table:
              if not counter in indexList:
                  result.append(row)
                  result_tracker.append(self.index_track[counter])
              counter += 1
          self.table = result
          self.index_track = result_tracker
          return self