CompileTimeConstantOperand<TF::GatherV2Op, 2>,     // $axis
      CompileTimeConstantOperand<TF::IRFFT2DOp, 1>,      // $fft_length
      CompileTimeConstantOperand<TF::IRFFT3DOp, 1>,      // $fft_length
      CompileTimeConstantOperand<TF::IRFFTOp, 1>,        // $fft_length
      CompileTimeConstantOperand<TF::InTopKV2Op, 2>,     // $k
      CompileTimeConstantOperand<TF::LinSpaceOp, 2>,     // $num

    return true;
  if ((op_name == "stablehlo.dynamic_slice" || op_name == "stablehlo.gather") &&
      field_name == "slice_sizes")
    return true;
  if (op_name == "stablehlo.fft" && field_name == "fft_length") return true;
  if ((op_name == "stablehlo.map" || op_name == "stablehlo.reduce" ||
       op_name == "stablehlo.reverse") &&
      field_name == "dimensions")
    return true;
  if (op_name == "stablehlo.pad" &&

    (convertIntAttrTo32Bit $new_axis_mask),
    (convertIntAttrTo32Bit $shrink_axis_mask),
    (GetBoolAttr<false>))>;

def LegalizeRfft2d : Pat<
  (TF_RFFT2DOp $input, $fft_length),
  (TFL_RFFT2dOp $input, $fft_length)>;

def LegalizeComplexAbs : Pat<(TF_ComplexAbsOp $arg), (TFL_ComplexAbsOp $arg)>;

def LegalizeReal : Pat<(TF_RealOp $arg), (TFL_RealOp $arg)>;

signal over the inner-most dimension of `input`.

The inner-most dimension of `input` is assumed to be the result of `RFFT`: the
`fft_length / 2 + 1` unique components of the DFT of a real-valued signal. If
`fft_length` is not provided, it is computed from the size of the inner-most
dimension of `input` (`fft_length = 2 * (inner - 1)`). If the FFT length used to
compute `input` is odd, it should be provided since it cannot be inferred
properly.

Since the DFT of a real signal is Hermitian-symmetric, `RFFT2D` only returns the
`fft_length / 2 + 1` unique components of the FFT for the inner-most dimension
of `output`: the zero-frequency term, followed by the `fft_length / 2`
positive-frequency terms.

Along each axis `RFFT2D` is computed on, if `fft_length` is smaller than the
corresponding dimension of `input`, the dimension is cropped. If it is larger,

  // CHECK: "mhlo.fft"(%arg0) <{fft_length = dense<8> : tensor<1xi64>, fft_type = #mhlo<fft_type RFFT>}> : (tensor<8xf32>
  %0 = "tf.RFFT"(%arg0, %fftlength) : (tensor<8xf32>, tensor<1xi32>) -> tensor<5xcomplex<f32>>
  func.return %0 : tensor<5xcomplex<f32>>
}

// -----

// CHECK-LABEL: func @rfft_1D_padded
func.func @rfft_1D_padded(%arg0: tensor<7xf32>) -> tensor<5xcomplex<f32>> {

      return failure();
    }
    int64_t fft_length;
    if (fft_length_attr.getNumElements() != 0) {
      fft_length = fft_length_attr.getValues<IntegerAttr>()[0].getInt();
    } else {
      return failure();
    }

    int64_t expected_dim = fft_length;
    std::string fft_string = "RFFT";
    if (typeid(OpTy) == typeid(TF::IRFFTOp)) {
      expected_dim = fft_length / 2 + 1;
      fft_string = "IRFFT";

  let hasCanonicalizer = 1;
}

def TFR_GetLengthOp : TFR_Op<"get_length", [Pure]> {
  let description = [{
    The `get_length` operation returns the number of tensors for a
    tfr.tensor_list.

    Example:

    ```mlir
    %2 = tfr.get_length(%1) : tfr.tensor -> index
    %2 = tfr.get_length %1 -> index
    ```
  }];

  let arguments = (ins TFR_TensorListType:$tensor_list);

	Accessasid uint16  // E
	Loginname  [8]byte // 10
	Flag1      byte    // 18
	Flag1b2    byte    // 19
}

type Bpxystat_t struct { // DSECT BPXYSTAT
	St_id           [4]uint8  // 0
	St_length       uint16    // 0x4
	St_version      uint16    // 0x6
	St_mode         uint32    // 0x8
	St_ino          uint32    // 0xc
	St_dev          uint32    // 0x10
	St_nlink        uint32    // 0x14

*   Add a bitwise module with bitwise_and, bitwise_or, bitwise_xor, and invert
    functions.
*   Add fixed-grid ODE integration routines.
*   Allow passing bounds to ScipyOptimizerInterface.
*   Correctness fixes for fft_length parameter to `tf.spectral.rfft` &
    `tf.spectral.irfft`.
*   Exported model signatures using the 'predict' method will no longer have
    their input and output keys silently ignored and rewritten to 'inputs' and