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

      params_->body_graph, "FakeQuantWithMinMaxArgs", "float_op");
  TF_AddInput(desc, params_->body_inputs[0]);
  TF_FinishOperation(desc, s_);
  ASSERT_EQ(TF_INVALID_ARGUMENT, TF_GetCode(s_));
  string msg(TF_Message(s_));
  EXPECT_NE(msg.find("Input 'inputs' passed int32 expected float while "
                     "building NodeDef 'float_op'"),
            msg.npos);
  TF_AbortWhile(params_.get());
}

  func.func @quantize_i8(%input : tensor<*xf32>, %scale : tensor<*xf32>, %zp : tensor<*xi32>) -> tensor<*xi8> {
    %float_zp = "tf.Cast"(%zp) {Truncate = false} : (tensor<*xi32>) -> tensor<*xf32>
    %div = "tf.Div"(%input, %scale) : (tensor<*xf32>, tensor<*xf32>) -> tensor<*xf32>
    %add = "tf.AddV2"(%div, %float_zp) : (tensor<*xf32>, tensor<*xf32>) -> tensor<*xf32>