code: def table_irs(self):
      b = ir.TrueIR()
      table_read = ir.TableRead(
          ir.TableNativeReader(
              resource("backward_compatability/1.1.0/table/0.ht"),
              None,
              False,
          ),
          False,
      )
      table_read_row_type = hl.dtype(
          "struct{idx: int32, f32: float32, i64: int64, m: float64, astruct: struct{a: int32, b: float64}, mstruct: struct{x: int32, y: str}, aset: set<str>, mset: set<float64>, d: dict<array<str>, float64>, md: dict<int32, str>, h38: locus<GRCh38>, ml: locus<GRCh37>, i: interval<locus<GRCh37>>, c: call, mc: call, t: tuple(call, str, str), mt: tuple(locus<GRCh37>, bool)}"
      )
  
      matrix_read = ir.MatrixRead(
          ir.MatrixNativeReader(
              resource(
                  "backward_compatability/1.0.0/matrix_table/0.hmt"
              ),
              None,
              False,
          ),
          False,
          False,
      )
  
      block_matrix_read = ir.BlockMatrixRead(
          ir.BlockMatrixNativeReader(resource("blockmatrix_example/0"))
      )
  
      aa = hl.literal([[0.00], [0.01], [0.02]])._ir
  
      table_irs = [
          ir.TableKeyBy(table_read, ["m", "d"], False),
          ir.TableFilter(table_read, b),
          table_read,
          ir.MatrixColsTable(matrix_read),
          ir.TableAggregateByKey(
              table_read, ir.MakeStruct([("a", ir.I32(5))])
          ),
          ir.TableKeyByAndAggregate(
              table_read,
              ir.MakeStruct([("a", ir.I32(5))]),
              ir.MakeStruct([("b", ir.I32(5))]),
              1,
              2,
          ),
          ir.TableJoin(table_read, ir.TableRange(100, 10), "inner", 1),
          ir.MatrixEntriesTable(matrix_read),
          ir.MatrixRowsTable(matrix_read),
          ir.TableParallelize(
              ir.MakeStruct(
                  [
                      (
                          "rows",
                          ir.Literal(
                              hl.tarray(hl.tstruct(a=hl.tint32)),
                              [{"a": None}, {"a": 5}, {"a": -3}],
                          ),
                      ),
                      ("global", ir.MakeStruct([])),
                  ]
              ),
              None,
          ),
          ir.TableMapRows(
              ir.TableKeyBy(table_read, []),
              ir.MakeStruct(
                  [
                      (
                          "a",
                          ir.GetField(
                              ir.Ref("row", table_read_row_type), "f32"
                          ),
                      ),
                      ("b", ir.F64(-2.11)),
                      ("c", ir.ApplyScanOp("Collect", [], [ir.I32(0)])),
                  ]
              ),
          ),
          ir.TableMapGlobals(
              table_read,
              ir.MakeStruct([("foo", ir.NA(hl.tarray(hl.tint32)))]),
          ),
          ir.TableRange(100, 10),
          ir.TableRepartition(
              table_read, 10, ir.RepartitionStrategy.COALESCE
          ),
          ir.TableUnion(
              [ir.TableRange(100, 10), ir.TableRange(50, 10)]
          ),
          ir.TableExplode(table_read, ["mset"]),
          ir.TableHead(table_read, 10),
          ir.TableOrderBy(
              ir.TableKeyBy(table_read, []), [("m", "A"), ("m", "D")]
          ),
          ir.TableDistinct(table_read),
          ir.CastMatrixToTable(matrix_read, "__entries", "__cols"),
          ir.TableRename(
              table_read,
              {"idx": "idx_foo"},
              {"global_f32": "global_foo"},
          ),
          ir.TableMultiWayZipJoin(
              [table_read, table_read], "__data", "__globals"
          ),
          ir.MatrixToTableApply(
              matrix_read,
              {
                  "name": "LinearRegressionRowsSingle",
                  "yFields": ["col_m"],
                  "xField": "entry_m",
                  "covFields": [],
                  "rowBlockSize": 10,
                  "passThrough": [],
              },
          ),
          ir.TableToTableApply(
              table_read,
              {
                  "name": "TableFilterPartitions",
                  "parts": [0],
                  "keep": True,
              },
          ),
          ir.BlockMatrixToTableApply(
              block_matrix_read,
              aa,
              {"name": "PCRelate", "maf": 0.01, "blockSize": 4096},
          ),
          ir.TableFilterIntervals(
              table_read,
              [
                  hl.utils.Interval(
                      hl.utils.Struct(row_idx=0),
                      hl.utils.Struct(row_idx=10),
                  )
              ],
              hl.tstruct(row_idx=hl.tint32),
              keep=False,
          ),
          ir.TableMapPartitions(
              table_read,
              "glob",
              "rows",
              ir.Ref("rows", hl.tstream(table_read_row_type)),
              0,
              1,
          ),
          ir.TableGen(
              contexts=ir.StreamRange(ir.I32(0), ir.I32(10), ir.I32(1)),
              globals=ir.MakeStruct([]),
              cname="contexts",
              gname="globals",
              body=ir.ToStream(
                  ir.MakeArray(
                      [ir.MakeStruct([("a", ir.I32(1))])], type=None
                  )
              ),
              partitioner=ir.Partitioner(
                  hl.tstruct(a=hl.tint),
                  [
                      hl.Interval(
                          hl.Struct(a=1), hl.Struct(a=2), True, True
                      )
                  ],
              ),
          ),
      ]
  
      return table_irs
  
imports: import re
  import unittest
  import numpy
  from numpy.testing import assert_array_equal
  import hail
  import hail.ir
  from hail.ir.renderer import CSERenderer
  from hail.expr import construct_expr
  from hail.expr.types import tint32
  from hail.utils.java import Env
  from hail.utils import new_temp_file
  from test.hail.helpers import *
label_desc: Use image node_id 1 for calling the TableIRTests obj's underlying member method code with example usage: obj.table_irs() and returns: table_irs