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));

          }
          dim {
            size: 1
          }
          dim {
            size: 256
          }
          dim {
            size: 186
          }
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {

          }
          dim {
            size: 1
          }
          dim {
            size: 256
          }
          dim {
            size: 186
          }
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {

			NumericRegexp: nil,
			Vars:          []interface{}{"jinzhu?", 1, 999.99, true, []byte("12345"), tt, &tt, nil, "w@g.\"com", myrole, pwd, floatVal},

          }
          dim {
            size: 1
          }
          dim {
            size: 256
          }
          dim {
            size: 186
          }
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {

          }
          dim {
            size: 1
          }
          dim {
            size: 256
          }
          dim {
            size: 186
          }
        }
        float_val: 1.0
      }
    }
  }
}
node {
  name: "BoxPredictor_4/ClassPredictor/weights/read"
  op: "Identity"
  input: "BoxPredictor_4/ClassPredictor/weights"
  attr {
    key: "T"
    value {

        rewriter.setInsertionPoint(quantizing_op);
        Operation* float_op = rewriter.clone(*quantizing_op);
        quantizing_op->setAttr(kDebugModeOpQuantAttrName,
                               rewriter.getUnitAttr());
        float_op->setAttr(kDebugModeOpFloatAttrName, rewriter.getUnitAttr());
        RewireFloatModelBackbone(quantizing_op, float_op);
        return success();
      }

    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 0.0
      }
    }
  }
}
node {
  name: "statefulpartitionedcall"
  op: "StatefulPartitionedCall"
  input: "const"
  input: "args_1"
  attr {
    key: "Tin"
    value {

    // a very expensive pattern.
    %round_cst = "tf.Const"() {value = dense<0.5> : tensor<f32>} : () -> tensor<f32>
    %float_zp = "tf.Cast"(%zp) {Truncate = false} : (tensor<*xi32>) -> tensor<*xf32>
    %zp_plus_round_cst = "tf.AddV2"(%float_zp, %round_cst) : (tensor<*xf32>, tensor<f32>) -> tensor<*xf32>

    %div = "tf.Div"(%input, %scale) : (tensor<*xf32>, tensor<*xf32>) -> tensor<*xf32>