if (!sgn_splat) return false;

  auto splat = dyn_cast<SplatElementsAttr>(float_or_int);
  if (auto float_spl = llvm::dyn_cast_if_present<FloatAttr>(splat),
      sgn_cst_spl = llvm::dyn_cast_if_present<FloatAttr>(sgn_splat);
      float_spl && sgn_cst_spl) {
    return IsSign(float_spl.getValue(), sgn_cst_spl.getValue());
  }
  if (auto int_spl = llvm::dyn_cast_if_present<IntegerAttr>(splat),

  ASSERT_THAT(op->outputs, SizeIs(1));

  auto float_graph = readonly_model_->subgraphs()->Get(0);
  auto float_op = float_graph->operators()->Get(0);
  const int float_input0_idx = float_op->inputs()->Get(0);
  const int float_input1_idx = float_op->inputs()->Get(1);
  const int float_output_idx = float_op->outputs()->Get(0);
  ASSERT_THAT(float_graph->tensors()->Get(float_input0_idx)->type(),
              Eq(TensorType_FLOAT32));

        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 2
          }
          dim {
            size: 2
          }
        }
        float_val: 1
        float_val: 2
        float_val: 3
        float_val: 4
      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "TensorListStack/element_shape"
  op: "Const"
  attr {
    key: "dtype"
    value {

    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 4
          }
        }
        float_val: 1.0
        float_val: 2.0
        float_val: 3.0
        float_val: 4.0
      }
    }
  }
}
node {
  name: "cst1"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {

  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: -0.5634322166442871
      }
    }
  }
}
node {
  name: "sequential/quant_dense/MatMul/kquant/FakeQuantWithMinMaxVars/ReadVariableOp"
  op: "Identity"

  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 1
      }
    }
  }
}
node {
  name: "Case/branch_index/_3"
  op: "_SwitchN"
  input: "Case/branch_index"
  input: "Case/branch_index"
  attr {
    key: "T"
    value {
      type: DT_INT32

  // DerivedAttr to populate the NodeDef.
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 2
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 3
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_DOUBLE
  // CHECK:   double_val: 4
  tf_executor.graph {

        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "x"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 3.0
      }
    }
  }
}
node {
  name: "y"

        key: "value"
        value {
          tensor {
            dtype: DT_FLOAT
            tensor_shape {
              dim {
                size: 10
              }
            }
            float_val: 2
          }
        }
      }
      experimental_debug_info {
        original_node_names: "const_2"
      }
    }
    ret {
      key: "bar"
      value: "const_2:output:0"
    }

  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "var1_add"
  op: "AssignAddVariableOp"
  input: "arg1"
  input: "var1_add/value"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT