code: def value_irs(self):
      env = self.value_irs_env()
      b = ir.TrueIR()
      c = ir.Ref("c", env["c"])
      i = ir.I32(5)
      j = ir.I32(7)
      a = ir.Ref("a", env["a"])
      st = ir.Ref("st", env["st"])
      whitenStream = ir.Ref("whitenStream")
      mat = ir.Ref("mat")
      aa = ir.Ref("aa", env["aa"])
      sta = ir.Ref("sta", env["sta"])
      sts = ir.Ref("sts", env["sts"])
      da = ir.Ref("da", env["da"])
      nd = ir.Ref("nd", env["nd"])
      v = ir.Ref("v", env["v"])
      s = ir.Ref("s", env["s"])
      t = ir.Ref("t", env["t"])
      call = ir.Ref("call", env["call"])
      rngState = ir.RNGStateLiteral()
  
      table = ir.TableRange(5, 3)
  
      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"))
      )
  
      def aggregate(x):
          return ir.TableAggregate(table, x)
  
      value_irs = [
          i,
          ir.I64(5),
          ir.F32(3.14),
          ir.F64(3.14),
          s,
          ir.TrueIR(),
          ir.FalseIR(),
          ir.Void(),
          ir.Cast(i, hl.tfloat64),
          ir.NA(hl.tint32),
          ir.IsNA(i),
          ir.If(b, i, j),
          ir.Coalesce(i, j),
          ir.Let("v", i, v),
          ir.Ref("x", env["x"]),
          ir.ApplyBinaryPrimOp("+", i, j),
          ir.ApplyUnaryPrimOp("-", i),
          ir.ApplyComparisonOp("EQ", i, j),
          ir.MakeArray(
              [i, ir.NA(hl.tint32), ir.I32(-3)], hl.tarray(hl.tint32)
          ),
          ir.ArrayRef(a, i),
          ir.ArrayLen(a),
          ir.ArraySort(
              ir.ToStream(a),
              "l",
              "r",
              ir.ApplyComparisonOp(
                  "LT", ir.Ref("l", hl.tint32), ir.Ref("r", hl.tint32)
              ),
          ),
          ir.ToSet(st),
          ir.ToDict(da),
          ir.ToArray(st),
          ir.CastToArray(ir.NA(hl.tset(hl.tint32))),
          ir.MakeNDArray(
              ir.MakeArray(
                  [ir.F64(-1.0), ir.F64(1.0)], hl.tarray(hl.tfloat64)
              ),
              ir.MakeTuple([ir.I64(1), ir.I64(2)]),
              ir.TrueIR(),
          ),
          ir.NDArrayShape(nd),
          ir.NDArrayReshape(nd, ir.MakeTuple([ir.I64(5)])),
          ir.NDArrayRef(nd, [ir.I64(1), ir.I64(2)]),
          ir.NDArrayMap(nd, "v", v),
          ir.NDArrayMatMul(nd, nd),
          ir.LowerBoundOnOrderedCollection(a, i, False),
          ir.GroupByKey(da),
          ir.RNGSplit(
              rngState, ir.MakeTuple([ir.I64(1), ir.I64(2), ir.I64(3)])
          ),
          ir.StreamMap(st, "v", v),
          ir.StreamZip([st, st], ["a", "b"], ir.TrueIR(), "ExtendNA"),
          ir.StreamFilter(st, "v", c),
          ir.StreamFlatMap(sta, "v", ir.ToStream(v)),
          ir.StreamFold(st, ir.I32(0), "x", "v", v),
          ir.StreamScan(st, ir.I32(0), "x", "v", v),
          ir.StreamWhiten(
              whitenStream, "newChunk", "prevWindow", 1, 1, 1, 1, False
          ),
          ir.StreamJoinRightDistinct(
              sts, sts, ["x"], ["x"], "l", "r", ir.I32(1), "left"
          ),
          ir.StreamFor(st, "v", ir.Void()),
          aggregate(ir.AggFilter(ir.TrueIR(), ir.I32(0), False)),
          aggregate(
              ir.AggExplode(
                  ir.StreamRange(ir.I32(0), ir.I32(2), ir.I32(1)),
                  "x",
                  ir.I32(0),
                  False,
              )
          ),
          aggregate(ir.AggGroupBy(ir.TrueIR(), ir.I32(0), False)),
          aggregate(
              ir.AggArrayPerElement(
                  ir.ToArray(
                      ir.StreamRange(ir.I32(0), ir.I32(2), ir.I32(1))
                  ),
                  "x",
                  "y",
                  ir.I32(0),
                  False,
              )
          ),
          aggregate(ir.ApplyAggOp("Collect", [], [ir.I32(0)])),
          aggregate(
              ir.ApplyAggOp("CallStats", [ir.I32(2)], [ir.NA(hl.tcall)])
          ),
          aggregate(
              ir.ApplyAggOp(
                  "TakeBy", [ir.I32(10)], [ir.F64(-2.11), ir.F64(-2.11)]
              )
          ),
          ir.Begin([ir.Void()]),
          ir.MakeStruct([("x", i)]),
          ir.SelectFields(s, ["x", "z"]),
          ir.InsertFields(s, [("x", i)], None),
          ir.GetField(s, "x"),
          ir.MakeTuple([i, b]),
          ir.GetTupleElement(t, 1),
          ir.Die(ir.Str("mumblefoo"), hl.tfloat64),
          ir.Apply("land", hl.tbool, b, c),
          ir.Apply("toFloat64", hl.tfloat64, i),
          ir.Literal(hl.tarray(hl.tint32), [1, 2, None]),
          ir.EncodedLiteral(hl.tarray(hl.tint32), [1, 2, None]),
          ir.TableCount(table),
          ir.TableGetGlobals(table),
          ir.TableCollect(ir.TableKeyBy(table, [], False)),
          ir.TableToValueApply(table, {"name": "ForceCountTable"}),
          ir.MatrixToValueApply(
              matrix_read, {"name": "ForceCountMatrixTable"}
          ),
          ir.TableAggregate(
              table,
              ir.MakeStruct(
                  [("foo", ir.ApplyAggOp("Collect", [], [ir.I32(0)]))]
              ),
          ),
          ir.TableWrite(
              table,
              ir.TableNativeWriter(
                  new_temp_file(), False, True, "fake_codec_spec$$"
              ),
          ),
          ir.TableWrite(
              table,
              ir.TableTextWriter(
                  new_temp_file(), None, True, "concatenated", ","
              ),
          ),
          ir.MatrixAggregate(
              matrix_read,
              ir.MakeStruct(
                  [("foo", ir.ApplyAggOp("Collect", [], [ir.I32(0)]))]
              ),
          ),
          ir.MatrixWrite(
              matrix_read,
              ir.MatrixNativeWriter(
                  new_temp_file(), False, False, "", None, None
              ),
          ),
          ir.MatrixWrite(
              matrix_read,
              ir.MatrixNativeWriter(
                  new_temp_file(),
                  False,
                  False,
                  "",
                  '[{"start":{"row_idx":0},"end":{"row_idx": 10},"includeStart":true,"includeEnd":false}]',
                  hl.dtype("array<interval<struct{row_idx:int32}>>"),
              ),
          ),
          ir.MatrixWrite(
              matrix_read,
              ir.MatrixVCFWriter(
                  new_temp_file(),
                  None,
                  ir.ExportType.CONCATENATED,
                  None,
                  False,
              ),
          ),
          ir.MatrixWrite(
              matrix_read, ir.MatrixGENWriter(new_temp_file(), 4)
          ),
          ir.MatrixWrite(
              matrix_read, ir.MatrixPLINKWriter(new_temp_file())
          ),
          ir.MatrixMultiWrite(
              [matrix_read, matrix_read],
              ir.MatrixNativeMultiWriter(
                  [new_temp_file(), new_temp_file()], False, False, None
              ),
          ),
          ir.BlockMatrixWrite(
              block_matrix_read,
              ir.BlockMatrixNativeWriter(
                  "fake.bm", False, False, False
              ),
          ),
          ir.LiftMeOut(ir.I32(1)),
          ir.BlockMatrixWrite(
              block_matrix_read,
              ir.BlockMatrixPersistWriter("x", "MEMORY_ONLY"),
          ),
      ]
  
      return value_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 2 for calling the ValueIRTests obj's underlying member method code with example usage: obj.value_irs() and returns: value_irs, ir