Imported Upstream version 1.7.0upstream/1.7.0

346 files changed, 14051 insertions, 1223 deletions

diff --git a/compiler/tflchef/CMakeLists.txt b/compiler/tflchef/CMakeLists.txt
index 71c5e2ab1..ebc873342 100644
--- a/compiler/tflchef/CMakeLists.txt
+++ b/compiler/tflchef/CMakeLists.txt
@@ -1,15 +1,19 @@
 nnas_find_package(Protobuf QUIET)
 
 if(NOT Protobuf_FOUND)
+  message(STATUS "Build tflchef: FAILED (missing Protobuf)")
   return()
 endif(NOT Protobuf_FOUND)
 
 if(NOT TARGET mio_tflite)
+  message(STATUS "Build tflchef: FAILED (missing mio_tflite)")
   return()
 endif(NOT TARGET mio_tflite)
 
 # Recipe Parser
 add_subdirectory(proto)
+# Log
+add_subdirectory(log)
 # Core Library
 add_subdirectory(core)
 # TFlite Library
diff --git a/compiler/tflchef/core/CMakeLists.txt b/compiler/tflchef/core/CMakeLists.txt
index 6a6282027..43f6b8b03 100644
--- a/compiler/tflchef/core/CMakeLists.txt
+++ b/compiler/tflchef/core/CMakeLists.txt
@@ -4,4 +4,6 @@ add_library(tflchef_core STATIC ${SOURCES})
 target_include_directories(tflchef_core PUBLIC include)
 target_include_directories(tflchef_core PRIVATE src)
 target_link_libraries(tflchef_core tflchef_proto)
+target_link_libraries(tflchef_core tflchef_log)
 target_link_libraries(tflchef_core mio_tflite)
+target_link_libraries(tflchef_core souschef)
diff --git a/compiler/tflchef/core/src/Convert.cpp b/compiler/tflchef/core/src/Convert.cpp
index 86a31d9b7..dc8e31db0 100644
--- a/compiler/tflchef/core/src/Convert.cpp
+++ b/compiler/tflchef/core/src/Convert.cpp
@@ -41,6 +41,8 @@ tflite::ActivationFunctionType as_tflite_activation(const tflchef::Activation &v
       return tflite::ActivationFunctionType_NONE;
     case tflchef::RELU:
       return tflite::ActivationFunctionType_RELU;
+    case tflchef::RELU_N1_TO_1:
+      return tflite::ActivationFunctionType_RELU_N1_TO_1;
     case tflchef::RELU6:
       return tflite::ActivationFunctionType_RELU6;
     default:
@@ -70,3 +72,18 @@ tflite::TensorType as_tflite_tensortype(const tflchef::TensorType &value)
 
   throw std::runtime_error{"Unknown tensor type"};
 }
+
+tflite::MirrorPadMode as_tflite_mirrorpadmode(const tflchef::MirrorPadMode &value)
+{
+  switch (value)
+  {
+    case tflchef::REFLECT:
+      return tflite::MirrorPadMode_REFLECT;
+    case tflchef::SYMMETRIC:
+      return tflite::MirrorPadMode_SYMMETRIC;
+    default:
+      break;
+  }
+
+  throw std::runtime_error{"Unknown mirrorpad mode"};
+}
diff --git a/compiler/tflchef/core/src/Convert.h b/compiler/tflchef/core/src/Convert.h
index ed15a5572..b56e6ef69 100644
--- a/compiler/tflchef/core/src/Convert.h
+++ b/compiler/tflchef/core/src/Convert.h
@@ -27,5 +27,6 @@
 tflite::Padding as_tflite_padding(const tflchef::Padding &value);
 tflite::ActivationFunctionType as_tflite_activation(const tflchef::Activation &value);
 tflite::TensorType as_tflite_tensortype(const tflchef::TensorType &value);
+tflite::MirrorPadMode as_tflite_mirrorpadmode(const tflchef::MirrorPadMode &value);
 
 #endif // __CONVERT_H__
diff --git a/compiler/tflchef/core/src/CustomOp/AddV2.cpp b/compiler/tflchef/core/src/CustomOp/AddV2.cpp
new file mode 100644
index 000000000..dffd336cd
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/AddV2.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AddV2.h"
+
+#include "flatbuffers/flexbuffers.h"
+
+flatbuffers::Offset<void> AddV2Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+AddV2Chef::custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.type() == "AddV2");
+
+  /**
+   * REGISTER_OP("AddV2")
+    .Input("x: T")
+    .Input("y: T")
+    .Output("z: T")
+    .Attr(
+        "T: {bfloat16, half, float, double, uint8, int8, int16, int32, int64, "
+        "complex64, complex128}")
+    .SetShapeFn(shape_inference::BroadcastBinaryOpShapeFn)
+    .SetIsAggregate()
+    .SetIsCommutative();
+   */
+
+  auto flex_buffers = std::make_unique<flexbuffers::Builder>();
+  size_t map_start = flex_buffers->StartMap();
+
+  // TODO Support more data types
+  flex_buffers->Int("T", tflite::TensorType_FLOAT32);
+
+  flex_buffers->EndMap(map_start);
+  flex_buffers->Finish();
+
+  auto circle_custom_options = fbb.CreateVector(flex_buffers->GetBuffer());
+  return circle_custom_options;
+}
+
+std::unique_ptr<OpChef> AddV2ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new AddV2Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/CustomOp/AddV2.h b/compiler/tflchef/core/src/CustomOp/AddV2.h
new file mode 100644
index 000000000..dbbaf5a62
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/AddV2.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ADDV2_H__
+#define __OP_ADDV2_H__
+
+#include "OpChef.h"
+
+class AddV2Chef final : public OpChef
+{
+public:
+  explicit AddV2Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CUSTOM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+  flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct AddV2ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ADDV2_H__
diff --git a/compiler/tflchef/core/src/CustomOp/All.cpp b/compiler/tflchef/core/src/CustomOp/All.cpp
new file mode 100644
index 000000000..b3ae821a4
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/All.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "All.h"
+
+#include "flatbuffers/flexbuffers.h"
+
+flatbuffers::Offset<void> AllChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+AllChef::custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.type() == "All");
+
+  /**
+   * REGISTER_OP("All")
+    .Input("input: bool")
+    .Input("reduction_indices: Tidx")
+    .Output("output: bool")
+    .Attr("keep_dims: bool = false")
+    .Attr("Tidx: {int32, int64} = DT_INT32")
+    .SetShapeFn(shape_inference::ReductionShape);
+   */
+
+  auto flex_buffers = std::make_unique<flexbuffers::Builder>();
+  size_t map_start = flex_buffers->StartMap();
+
+  // TODO Support more data types
+  flex_buffers->Int("Tidx", tflite::TensorType_INT32);
+  flex_buffers->Bool("keep_dims", operation.all_options().keep_dims());
+
+  flex_buffers->EndMap(map_start);
+  flex_buffers->Finish();
+
+  auto circle_custom_options = fbb.CreateVector(flex_buffers->GetBuffer());
+  return circle_custom_options;
+}
+
+std::unique_ptr<OpChef> AllChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new AllChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/CustomOp/All.h b/compiler/tflchef/core/src/CustomOp/All.h
new file mode 100644
index 000000000..f7949f3d2
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/All.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ALL_H__
+#define __OP_ALL_H__
+
+#include "OpChef.h"
+
+class AllChef final : public OpChef
+{
+public:
+  explicit AllChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CUSTOM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+  flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct AllChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ALL_H__
diff --git a/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.cpp b/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.cpp
new file mode 100644
index 000000000..595f3b9bb
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BatchMatMulV2.h"
+
+#include "flatbuffers/flexbuffers.h"
+
+flatbuffers::Offset<void> BatchMatMulV2Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+BatchMatMulV2Chef::custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.type() == "BatchMatMulV2");
+
+  /**
+   * REGISTER_OP("BatchMatMulV2")
+    .Input("x: T")
+    .Input("y: T")
+    .Output("output: T")
+    .Attr(
+        "T: {bfloat16, half, float, double, int32, int64, complex64, "
+        "complex128}")
+    .Attr("adj_x: bool = false")
+    .Attr("adj_y: bool = false")
+    .SetShapeFn(shape_inference::BatchMatMulV2Shape);
+   */
+
+  auto flex_buffers = std::make_unique<flexbuffers::Builder>();
+  size_t map_start = flex_buffers->StartMap();
+
+  flex_buffers->Bool("adj_x", operation.batch_matmul_options().adj_x());
+  flex_buffers->Bool("adj_y", operation.batch_matmul_options().adj_y());
+  // TODO Support more data types
+  flex_buffers->Int("T", tflite::TensorType_FLOAT32);
+
+  flex_buffers->EndMap(map_start);
+  flex_buffers->Finish();
+
+  auto circle_custom_options = fbb.CreateVector(flex_buffers->GetBuffer());
+  return circle_custom_options;
+}
+
+std::unique_ptr<OpChef> BatchMatMulV2ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new BatchMatMulV2Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.h b/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.h
new file mode 100644
index 000000000..d20f4d2a5
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/BatchMatMulV2.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_BATCH_MATMUL_V2_H__
+#define __OP_BATCH_MATMUL_V2_H__
+
+#include "OpChef.h"
+
+class BatchMatMulV2Chef final : public OpChef
+{
+public:
+  explicit BatchMatMulV2Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CUSTOM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+  flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct BatchMatMulV2ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_BATCH_MATMUL_V2_H__
diff --git a/compiler/tflchef/core/src/CustomOp/MatMul.cpp b/compiler/tflchef/core/src/CustomOp/MatMul.cpp
new file mode 100644
index 000000000..ba34aa8db
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/MatMul.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatMul.h"
+
+#include "flatbuffers/flexbuffers.h"
+
+flatbuffers::Offset<void> MatMulChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+MatMulChef::custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.type() == "MatMul");
+
+  /**
+   * REGISTER_OP("MatMul")
+    .Input("a: T")
+    .Input("b: T")
+    .Output("product: T")
+    .Attr("transpose_a: bool = false")
+    .Attr("transpose_b: bool = false")
+    .Attr("T: {half, float, double, int32, complex64, complex128}")
+    .SetShapeFn(shape_inference::MatMulShape)
+   */
+
+  auto flex_buffers = std::make_unique<flexbuffers::Builder>();
+  size_t map_start = flex_buffers->StartMap();
+
+  flex_buffers->Bool("transpose_a", operation.matmul_options().transpose_a());
+  flex_buffers->Bool("transpose_b", operation.matmul_options().transpose_b());
+  // TODO how do we support other types?
+  flex_buffers->Int("T", tflite::TensorType_FLOAT32);
+
+  flex_buffers->EndMap(map_start);
+  flex_buffers->Finish();
+
+  auto circle_custom_options = fbb.CreateVector(flex_buffers->GetBuffer());
+  return circle_custom_options;
+}
+
+std::unique_ptr<OpChef> MatMulChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MatMulChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/CustomOp/MatMul.h b/compiler/tflchef/core/src/CustomOp/MatMul.h
new file mode 100644
index 000000000..b0307f977
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/MatMul.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MATMUL_H__
+#define __OP_MATMUL_H__
+
+#include "OpChef.h"
+
+class MatMulChef final : public OpChef
+{
+public:
+  explicit MatMulChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CUSTOM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+  flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MatMulChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MATMUL_H__
diff --git a/compiler/tflchef/core/src/CustomOp/MatrixBandPart.cpp b/compiler/tflchef/core/src/CustomOp/MatrixBandPart.cpp
new file mode 100644
index 000000000..d12597edb
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/MatrixBandPart.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatrixBandPart.h"
+
+#include "flatbuffers/flexbuffers.h"
+
+flatbuffers::Offset<void> MatrixBandPartChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+MatrixBandPartChef::custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.type() == "MatrixBandPart");
+
+  /**
+   * REGISTER_OP("MatrixBandPart")
+    .Input("input: T")
+    .Input("num_lower: Tindex")
+    .Input("num_upper: Tindex")
+    .Output("band: T")
+    .Attr("T: type")
+    .Attr("Tindex: {int32, int64} = DT_INT64")
+    .SetShapeFn(shape_inference::UnchangedShape);
+   */
+
+  auto flex_buffers = std::make_unique<flexbuffers::Builder>();
+  size_t map_start = flex_buffers->StartMap();
+
+  // TODO Support more data types
+  flex_buffers->Int("T", tflite::TensorType_FLOAT32);
+  flex_buffers->Int("Tindex", tflite::TensorType_INT64);
+
+  flex_buffers->EndMap(map_start);
+  flex_buffers->Finish();
+
+  auto circle_custom_options = fbb.CreateVector(flex_buffers->GetBuffer());
+  return circle_custom_options;
+}
+
+std::unique_ptr<OpChef> MatrixBandPartChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MatrixBandPartChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/CustomOp/MatrixBandPart.h b/compiler/tflchef/core/src/CustomOp/MatrixBandPart.h
new file mode 100644
index 000000000..54a8a3afb
--- /dev/null
+++ b/compiler/tflchef/core/src/CustomOp/MatrixBandPart.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MATRIXBANDPART_H__
+#define __OP_MATRIXBANDPART_H__
+
+#include "OpChef.h"
+
+class MatrixBandPartChef final : public OpChef
+{
+public:
+  explicit MatrixBandPartChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CUSTOM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+  flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MatrixBandPartChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MATRIXBANDPART_H__
diff --git a/compiler/tflchef/core/src/Data/Constant.h b/compiler/tflchef/core/src/Data/Constant.h
deleted file mode 100644
index ebe1f3d93..000000000
--- a/compiler/tflchef/core/src/Data/Constant.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __CONSTANT_FILLER_H__
-#define __CONSTANT_FILLER_H__
-
-#include "DataChef.h"
-#include "LexicalCast.h"
-
-template <typename T> class ConstantDataChef final : public DataChef
-{
-public:
-  ConstantDataChef(const T &value) : _value{value}
-  {
-    // DO NOTHING
-  }
-
-public:
-  std::vector<uint8_t> generate(int32_t count) const override
-  {
-    std::vector<uint8_t> res;
-
-    for (uint32_t n = 0; n < count; ++n)
-    {
-      const uint8_t *arr = reinterpret_cast<const uint8_t *>(&_value);
-
-      for (uint32_t b = 0; b < sizeof(T); ++b)
-      {
-        res.emplace_back(arr[b]);
-      }
-    }
-
-    return res;
-  }
-
-private:
-  T _value;
-};
-
-template <typename T> struct ConstantDataChefFactory : public DataChefFactory
-{
-  std::unique_ptr<DataChef> create(const Arguments &args) const
-  {
-    auto const value = to_number<T>(args.value(0));
-    return std::unique_ptr<DataChef>{new ConstantDataChef<T>{value}};
-  }
-};
-
-#endif // __CONSTANT_FILLER_H__
diff --git a/compiler/tflchef/core/src/Data/Explicit.h b/compiler/tflchef/core/src/Data/Explicit.h
deleted file mode 100644
index 088e791b9..000000000
--- a/compiler/tflchef/core/src/Data/Explicit.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __EXPLICIT_FILLER_H__
-#define __EXPLICIT_FILLER_H__
-
-#include "DataChef.h"
-#include "LexicalCast.h"
-
-#include <vector>
-
-template <typename T> class ExplicitDataChef final : public DataChef
-{
-public:
-  ExplicitDataChef()
-  {
-    // DO NOTHING
-  }
-
-public:
-  std::vector<uint8_t> generate(int32_t count) const override
-  {
-    std::vector<uint8_t> res;
-
-    for (uint32_t n = 0; n < count; ++n)
-    {
-      T const value = (n < _values.size()) ? _values.at(n) : T{};
-      const uint8_t *arr = reinterpret_cast<const uint8_t *>(&value);
-
-      for (uint32_t b = 0; b < sizeof(T); ++b)
-      {
-        res.emplace_back(arr[b]);
-      }
-    }
-
-    return res;
-  }
-
-public:
-  void insert(const T &value) { _values.emplace_back(value); }
-
-private:
-  std::vector<T> _values;
-};
-
-template <typename T> struct ExplicitDataChefFactory : public DataChefFactory
-{
-  std::unique_ptr<DataChef> create(const Arguments &args) const
-  {
-    std::unique_ptr<ExplicitDataChef<T>> res{new ExplicitDataChef<T>};
-
-    for (uint32_t n = 0; n < args.count(); ++n)
-    {
-      auto const value = to_number<T>(args.value(n));
-      res->insert(value);
-    }
-
-    return std::move(res);
-  }
-};
-
-#endif // __EXPLICIT_FILLER_H__
diff --git a/compiler/tflchef/core/src/Data/Gaussian.cpp b/compiler/tflchef/core/src/Data/Gaussian.cpp
deleted file mode 100644
index c515d1104..000000000
--- a/compiler/tflchef/core/src/Data/Gaussian.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "Gaussian.h"
-#include "LexicalCast.h"
-
-#include <random>
-#include <chrono>
-
-#include <cassert>
-#include <stdexcept>
-
-std::vector<uint8_t> GaussianFloat32DataChef::generate(int32_t count) const
-{
-  // TODO Support seed value override
-  int seed = std::chrono::system_clock::now().time_since_epoch().count();
-
-  std::minstd_rand rand{seed};
-  std::normal_distribution<float> dist{_mean, _stddev};
-
-  std::vector<uint8_t> res;
-
-  for (uint32_t n = 0; n < count; ++n)
-  {
-    auto const value = dist(rand);
-    auto const arr = reinterpret_cast<const uint8_t *>(&value);
-
-    for (uint32_t b = 0; b < sizeof(float); ++b)
-    {
-      res.emplace_back(arr[b]);
-    }
-  }
-
-  return res;
-}
-
-std::vector<uint8_t> GaussianInt32DataChef::generate(int32_t count) const
-{
-  // TODO Support seed value override
-  int seed = std::chrono::system_clock::now().time_since_epoch().count();
-
-  std::minstd_rand rand{seed};
-  std::normal_distribution<float> dist{_mean, _stddev};
-
-  std::vector<uint8_t> res;
-
-  for (uint32_t n = 0; n < count; ++n)
-  {
-    auto const value = static_cast<int32_t>(dist(rand));
-    auto const arr = reinterpret_cast<const uint8_t *>(&value);
-
-    for (uint32_t b = 0; b < sizeof(int32_t); ++b)
-    {
-      res.emplace_back(arr[b]);
-    }
-  }
-
-  return res;
-}
-
-std::vector<uint8_t> GaussianUint8DataChef::generate(int32_t count) const
-{
-  // TODO Support seed value override
-  int seed = std::chrono::system_clock::now().time_since_epoch().count();
-
-  std::minstd_rand rand{seed};
-  std::normal_distribution<float> dist{_mean, _stddev};
-
-  std::vector<uint8_t> res;
-
-  for (uint32_t n = 0; n < count; ++n)
-  {
-    auto const value = static_cast<uint8_t>(dist(rand));        // uint8_t for data type
-    auto const arr = reinterpret_cast<const uint8_t *>(&value); // uint8_t for byte streaming
-
-    for (uint32_t b = 0; b < sizeof(uint8_t); ++b)
-    {
-      res.emplace_back(arr[b]);
-    }
-  }
-
-  return res;
-}
-
-std::unique_ptr<DataChef> GaussianFloat32DataChefFactory::create(const Arguments &args) const
-{
-  if (args.count() != 2)
-  {
-    throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
-  }
-
-  auto const mean = to_number<float>(args.value(0));
-  auto const stddev = to_number<float>(args.value(1));
-
-  return std::unique_ptr<DataChef>{new GaussianFloat32DataChef{mean, stddev}};
-}
-
-std::unique_ptr<DataChef> GaussianInt32DataChefFactory::create(const Arguments &args) const
-{
-  if (args.count() != 2)
-  {
-    throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
-  }
-
-  auto const mean = to_number<float>(args.value(0));
-  auto const stddev = to_number<float>(args.value(1));
-
-  return std::unique_ptr<DataChef>{new GaussianInt32DataChef{mean, stddev}};
-}
-
-std::unique_ptr<DataChef> GaussianUint8DataChefFactory::create(const Arguments &args) const
-{
-  if (args.count() != 2)
-  {
-    throw std::runtime_error{"invalid argument count: two arguments (mean/stddev) are expected"};
-  }
-
-  auto const mean = to_number<float>(args.value(0));
-  auto const stddev = to_number<float>(args.value(1));
-
-  return std::unique_ptr<DataChef>{new GaussianUint8DataChef{mean, stddev}};
-}
diff --git a/compiler/tflchef/core/src/Data/Gaussian.h b/compiler/tflchef/core/src/Data/Gaussian.h
deleted file mode 100644
index 81a28d2d1..000000000
--- a/compiler/tflchef/core/src/Data/Gaussian.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __GAUSSIAN_FILLER_H__
-#define __GAUSSIAN_FILLER_H__
-
-#include "DataChef.h"
-
-/**
- * @brief Generate a sequence of random values according to the gaussian(=normal) distribution
- */
-class GaussianFloat32DataChef final : public DataChef
-{
-public:
-  GaussianFloat32DataChef(float mean, float stddev) : _mean{mean}, _stddev{stddev}
-  {
-    // DO NOTHING
-  }
-
-public:
-  std::vector<uint8_t> generate(int32_t count) const override;
-
-private:
-  float _mean;
-  float _stddev;
-};
-
-class GaussianInt32DataChef final : public DataChef
-{
-public:
-  GaussianInt32DataChef(float mean, float stddev) : _mean{mean}, _stddev{stddev}
-  {
-    // DO NOTHING
-  }
-
-public:
-  std::vector<uint8_t> generate(int32_t count) const override;
-
-private:
-  float _mean;
-  float _stddev;
-};
-
-class GaussianUint8DataChef final : public DataChef
-{
-public:
-  GaussianUint8DataChef(float mean, float stddev) : _mean{mean}, _stddev{stddev}
-  {
-    // DO NOTHING
-  }
-
-public:
-  std::vector<uint8_t> generate(int32_t count) const override;
-
-private:
-  float _mean;
-  float _stddev;
-};
-
-struct GaussianFloat32DataChefFactory : public DataChefFactory
-{
-  std::unique_ptr<DataChef> create(const Arguments &args) const;
-};
-
-struct GaussianInt32DataChefFactory : public DataChefFactory
-{
-  std::unique_ptr<DataChef> create(const Arguments &args) const;
-};
-
-struct GaussianUint8DataChefFactory : public DataChefFactory
-{
-  std::unique_ptr<DataChef> create(const Arguments &args) const;
-};
-
-#endif // __GAUSSIAN_FILLER_H__
diff --git a/compiler/tflchef/core/src/DataChef.def b/compiler/tflchef/core/src/DataChef.def
deleted file mode 100644
index 89d34a202..000000000
--- a/compiler/tflchef/core/src/DataChef.def
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef DATA_CHEF
-#error "Define DATA_CHEF first"
-#endif // DATA_CHEF
-
-// DATA_CHEF(TYPE, NAME, FACTORY_CLASS)
-//  "TYPE" SHOULD BE an enum tag of tflchef::TensorType
-DATA_CHEF(FLOAT32, constant, ConstantDataChefFactory<float>)
-DATA_CHEF(BOOL, constant, ConstantDataChefFactory<bool>)
-DATA_CHEF(INT32, explicit, ExplicitDataChefFactory<int>)
-DATA_CHEF(UINT8, explicit, ExplicitDataChefFactory<uint8_t>)
-DATA_CHEF(BOOL, explicit, ExplicitDataChefFactory<bool>)
-DATA_CHEF(FLOAT32, explicit, ExplicitDataChefFactory<float>)
-DATA_CHEF(FLOAT32, gaussian, GaussianFloat32DataChefFactory)
-DATA_CHEF(INT32, gaussian, GaussianInt32DataChefFactory)
-DATA_CHEF(UINT8, gaussian, GaussianUint8DataChefFactory)
diff --git a/compiler/tflchef/core/src/DataChef.h b/compiler/tflchef/core/src/DataChef.h
deleted file mode 100644
index d0571028a..000000000
--- a/compiler/tflchef/core/src/DataChef.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DATA_CHEF_H__
-#define __DATA_CHEF_H__
-
-#include "Arguments.h"
-
-#include <cstdint>
-#include <memory>
-#include <vector>
-
-using Data = std::vector<uint8_t>;
-
-/**
- * @brief Data Generator
- */
-struct DataChef
-{
-  virtual ~DataChef() = default;
-
-  // TODO Allow users to query the type of elements that this DataChef generates
-
-  /**
-   * @brief Generate a sequence of 'count' elements as a byte sequence
-   *
-   * Let D be the return value of generate(N).
-   * Then, D.size() == N * sizeof(T) where T is the element type.
-   */
-  virtual Data generate(int32_t count) const = 0;
-};
-
-/**
- * @brief Data Generator Factory
- */
-struct DataChefFactory
-{
-  virtual ~DataChefFactory() = default;
-
-  virtual std::unique_ptr<DataChef> create(const Arguments &args) const = 0;
-};
-
-#endif // __DATA_CHEF_H__
diff --git a/compiler/tflchef/core/src/Dataset.h b/compiler/tflchef/core/src/Dataset.h
deleted file mode 100644
index 9d5c7a43f..000000000
--- a/compiler/tflchef/core/src/Dataset.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DATASET_H__
-#define __DATASET_H__
-
-#include <vector>
-
-template <typename T> class Dataset
-{
-public:
-  Dataset(const std::vector<T> &vec) : _vec{vec}
-  {
-    // DO NOTHING
-  }
-
-public:
-  Dataset(std::vector<T> &&vec) : _vec{std::move(vec)}
-  {
-    // DO NOTHING
-  }
-
-public:
-  template <typename Func> auto map(Func f) const -> Dataset<decltype(f(std::declval<T>()))>
-  {
-    using U = decltype(f(std::declval<T>()));
-    std::vector<U> res;
-
-    for (const auto &elem : _vec)
-    {
-      res.emplace_back(f(elem));
-    }
-
-    return Dataset<U>(std::move(res));
-  }
-
-public:
-  const std::vector<T> &vectorize(void) const { return _vec; }
-
-private:
-  std::vector<T> _vec;
-};
-
-#endif // __DATASET_H__
diff --git a/compiler/tflchef/core/src/LexicalCast.cpp b/compiler/tflchef/core/src/LexicalCast.cpp
deleted file mode 100644
index 38a5f9290..000000000
--- a/compiler/tflchef/core/src/LexicalCast.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "LexicalCast.h"
-
-#include <cassert>
-#include <limits>
-
-template <> float to_number(const std::string &s) { return std::stof(s); }
-template <> int to_number(const std::string &s) { return std::stoi(s); }
-template <> uint8_t to_number(const std::string &s)
-{
-  int temp = std::stoi(s);
-  assert(temp >= 0);
-  assert(temp <= std::numeric_limits<uint8_t>::max());
-  return static_cast<uint8_t>(temp);
-}
-template <> bool to_number(const std::string &s)
-{
-  if (std::stoi(s) || s == "T" || s == "t" || s == "TRUE" || s == "true")
-    return true;
-  return false;
-}
diff --git a/compiler/tflchef/core/src/ModelChef.cpp b/compiler/tflchef/core/src/ModelChef.cpp
index 2c69efd4b..932a649c5 100644
--- a/compiler/tflchef/core/src/ModelChef.cpp
+++ b/compiler/tflchef/core/src/ModelChef.cpp
@@ -15,17 +15,19 @@
  */
 
 #include "tflchef/ModelChef.h"
-#include "Arguments.h"
+#include <souschef/RangedArguments.h>
+#include <souschef/Registry.h>
 
 #include "Convert.h"
 
-#include "DataChef.h"
-#include "DataChefs.h"
+#include <souschef/DataChefs.h>
 
 #include "OpChef.h"
 #include "OpChefs.h"
 
-#include "Dataset.h"
+#include <souschef/Dataset.h>
+
+#include "Log.h"
 
 #include <iterator>
 #include <map>
@@ -42,34 +44,7 @@
 namespace
 {
 
-template <typename InputIt> class RangedArguments : public Arguments
-{
-public:
-  RangedArguments(InputIt beg, InputIt end) : _beg{beg}, _end{end}
-  {
-    // DO NOTHING
-  }
-
-public:
-  uint32_t count(void) const override { return _end - _beg; }
-
-public:
-  const std::string &value(uint32_t n) const override { return *(_beg + n); }
-
-private:
-  InputIt _beg;
-  InputIt _end;
-};
-
-template <typename InputIt> RangedArguments<InputIt> ranged_arguments(InputIt beg, InputIt end)
-{
-  return RangedArguments<InputIt>{beg, end};
-}
-
-} // namespace
-
-namespace
-{
+using namespace souschef;
 
 template <typename T> std::vector<T> as_vector(const ::google::protobuf::RepeatedPtrField<T> &field)
 {
@@ -147,20 +122,6 @@ private:
 namespace
 {
 
-template <typename T> class Registry
-{
-public:
-  void add(const std::string &name, std::unique_ptr<T> &&entry)
-  {
-    _content[name] = std::move(entry);
-  }
-
-  const T &lookup(const std::string &name) const { return *(_content.at(name)); }
-
-private:
-  std::map<std::string, std::unique_ptr<T>> _content;
-};
-
 struct DataChefRegistry final : public Registry<DataChefFactory>
 {
 };
@@ -168,6 +129,7 @@ struct DataChefRegistry final : public Registry<DataChefFactory>
 DataChefRegistry &data_chef_registry(const tflchef::TensorType &type)
 {
   static DataChefRegistry s32;
+  static DataChefRegistry s64;
   static DataChefRegistry fp32;
   static DataChefRegistry u8;
   static DataChefRegistry boolean;
@@ -176,6 +138,8 @@ DataChefRegistry &data_chef_registry(const tflchef::TensorType &type)
   {
     case tflchef::INT32:
       return s32;
+    case tflchef::INT64:
+      return s64;
     case tflchef::FLOAT32:
       return fp32;
     case tflchef::UINT8:
@@ -199,14 +163,54 @@ OpChefRegistry &op_chef_registry(void)
   return registry;
 }
 
-// @brief This will prepare a set of unique operator codes in the mode recipe
-std::set<tflite::BuiltinOperator> gather_opcode_set(const ::tflchef::ModelRecipe &model_recipe)
+/// @brief This will prepare a map of unique builtin codes in the model recipe
+std::map<tflite::BuiltinOperator, int32_t>
+gather_builtincode_map(const ::tflchef::ModelRecipe &model_recipe)
+{
+  // Key and value of the map are BuiltinOperator and operator version
+  std::map<tflite::BuiltinOperator, int32_t> builtin_map;
+
+  for (const auto &operation : model_recipe.operation())
+  {
+    auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
+    if (op_chef->code() == tflite::BuiltinOperator_CUSTOM)
+      continue;
+
+    // Various operation version is unified as the highest version among them
+    if (builtin_map.find(op_chef->code()) == builtin_map.end() ||
+        builtin_map[op_chef->code()] < operation.version())
+      builtin_map[op_chef->code()] = operation.version();
+  }
+
+  // Add ops used in Graphs(subgraphs)
+  for (int g = 0; g < model_recipe.graph_size(); ++g)
+  {
+    const auto &graph = model_recipe.graph(g);
+    for (const auto &operation : graph.operation())
+    {
+      auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
+      if (op_chef->code() == tflite::BuiltinOperator_CUSTOM)
+        continue;
+
+      // Various operation version is unified as the highest version among them
+      if (builtin_map.find(op_chef->code()) == builtin_map.end() ||
+          builtin_map[op_chef->code()] < operation.version())
+        builtin_map[op_chef->code()] = operation.version();
+    }
+  }
+
+  return builtin_map;
+}
+
+/// @brief This will prepare a set of unique custom codes in the mode recipe
+std::set<std::string> gather_customcode_set(const ::tflchef::ModelRecipe &model_recipe)
 {
-  std::set<tflite::BuiltinOperator> opcode_set;
+  std::set<std::string> customcode_set;
   for (const auto &operation : model_recipe.operation())
   {
     auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
-    opcode_set.insert(op_chef->code());
+    if (op_chef->code() == tflite::BuiltinOperator_CUSTOM)
+      customcode_set.insert(operation.type());
   }
 
   // Add ops used in Graphs(subgraphs)
@@ -216,525 +220,386 @@ std::set<tflite::BuiltinOperator> gather_opcode_set(const ::tflchef::ModelRecipe
     for (const auto &operation : graph.operation())
     {
       auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
-      opcode_set.insert(op_chef->code());
+      if (op_chef->code() == tflite::BuiltinOperator_CUSTOM)
+        customcode_set.insert(operation.type());
     }
   }
 
-  return opcode_set;
+  return customcode_set;
 }
 
 } // namespace
 
-namespace tflchef
+namespace
 {
 
-/**
- * @brief Generate a (in-memory) TensorFlow Lite model from a given model recipe
- */
-GeneratedModel cook(const ::tflchef::ModelRecipe &model_recipe)
+struct CookParams
 {
-// Initialize Op Chef Registry
-#define OP_CHEF(NAME, FACTORY_CLASS) \
-  op_chef_registry().add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
-#include "OpChef.def"
-#undef OP_CHEF
+  std::vector<flatbuffers::Offset<::tflite::Buffer>> &buffer_vec;
+  std::vector<flatbuffers::Offset<::tflite::OperatorCode>> &code_vec;
+  std::vector<flatbuffers::Offset<::tflite::SubGraph>> &subgraph_vec;
+  std::unique_ptr<flatbuffers::FlatBufferBuilder> &flatbuffer_builder;
+  std::map<tflite::BuiltinOperator, int32_t> &builtin_code_map;
+  std::string noname;
+};
 
-// Initialize Data Chef Registry
-#define DATA_CHEF(TYPE, NAME, FACTORY_CLASS) \
-  data_chef_registry(::tflchef::TYPE)        \
-      .add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
-#include "DataChef.def"
-#undef DATA_CHEF
+template <typename T> void cook_graph(const T &graph, CookParams &cp)
+{
+  LOGGER(l);
 
-  //
-  // Create FlatBufferBuilder
-  //
-  auto flatbuffer_builder =
-      std::unique_ptr<flatbuffers::FlatBufferBuilder>(new flatbuffers::FlatBufferBuilder(1024));
+  std::vector<flatbuffers::Offset<::tflite::Buffer>> &buffer_vec = cp.buffer_vec;
+  std::vector<flatbuffers::Offset<::tflite::OperatorCode>> &code_vec = cp.code_vec;
+  std::vector<flatbuffers::Offset<::tflite::SubGraph>> &subgraph_vec = cp.subgraph_vec;
+  std::unique_ptr<flatbuffers::FlatBufferBuilder> &flatbuffer_builder = cp.flatbuffer_builder;
+  std::map<tflite::BuiltinOperator, int32_t> &builtin_code_map = cp.builtin_code_map;
 
   // Operand-related
-  std::vector<flatbuffers::Offset<::tflite::Buffer>> buffer_vec;
+  std::vector<flatbuffers::Offset<::tflite::Tensor>> tensor_vec;
 
   // Operation-related
-  std::vector<flatbuffers::Offset<::tflite::OperatorCode>> code_vec;
+  std::vector<flatbuffers::Offset<::tflite::Operator>> operator_vec;
+
+  // default name for graph
+  std::string graph_name = cp.noname;
+  if (graph.has_name())
+    graph_name = graph.name();
+
+  // Tensor Name -> Tensor ID mapping (per Graph)
+  std::map<std::string, int32_t> symbol_table;
+
+  auto lookup = [&symbol_table, &graph_name](const std::string &name) {
+    if (symbol_table.find(name) != symbol_table.end())
+      return symbol_table.at(name);
+    else if (name == "")
+      return -1; // -1 in TFLite means that optional input tensor is empty.
+    else
+    {
+      std::string msg = "tflchef : input not found in " + graph_name + " graph";
+      throw std::runtime_error(msg.c_str());
+    }
+  };
 
-  // Graphs-related
-  std::vector<flatbuffers::Offset<::tflite::SubGraph>> subgraph_vec;
+  int32_t buffer_start = buffer_vec.size();
+  int32_t buffer_index = 0;
 
-  // Create OperatorCode
-  std::set<tflite::BuiltinOperator> opcode_set = gather_opcode_set(model_recipe);
-  for (auto opcode : opcode_set)
+  // Create buffer(s) 1~n(I) for input(s)
+  const auto size_input = graph.input_size();
+  for (int ci = 0; ci < size_input; ++ci)
   {
-    tflite::OperatorCodeBuilder code_builder{*flatbuffer_builder};
-    code_builder.add_builtin_code(opcode);
-    auto code = code_builder.Finish();
-    // Update OperatorCode vector
-    code_vec.emplace_back(code);
+    tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
+    buffer_vec.emplace_back(buffer_builder.Finish());
   }
-
-  // Create an Empty Buffer
-  //
-  // Buffer 0 SHOULD be an empty buffer in TensorFlow Lite model file
-  // (Please refer to the comment for Tensor.buffer field in schema)
+  // Create buffer(s) n(I)+1~n(I)+n(O) for output(s)
+  const auto size_output = graph.output_size();
+  for (int co = 0; co < size_output; ++co)
   {
     tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
     buffer_vec.emplace_back(buffer_builder.Finish());
   }
 
-  //
-  // Create Main graph
-  //
-  {
-    // Operand-related
-    std::vector<flatbuffers::Offset<::tflite::Tensor>> tensor_vec;
+  auto input_names = as_dataset(graph.input()).vectorize();
+  auto output_names = as_dataset(graph.output()).vectorize();
 
-    // Operation-related
-    std::vector<flatbuffers::Offset<::tflite::Operator>> operator_vec;
-
-    // Tensor Name -> Tensor ID mapping (per Graph)
-    std::map<std::string, int32_t> symbol_table;
-
-    auto lookup = [&symbol_table](const std::string &name) { return symbol_table.at(name); };
+  for (const auto &operand : graph.operand())
+  {
+    assert(operand.has_name());
 
-    int32_t buffer_start = buffer_vec.size();
-    int32_t buffer_index = 0;
+    assert(operand.has_type());
 
-    // Create buffer(s) 1~n(I) for input(s)
-    const auto size_input = model_recipe.input_size();
-    for (int ci = 0; ci < size_input; ++ci)
+    flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape;
+    std::vector<int32_t> dims;
+    if (operand.has_shape())
     {
-      tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-      buffer_vec.emplace_back(buffer_builder.Finish());
-    }
-    // Create buffer(s) n(I)+1~n(I)+n(O) for output(s)
-    const auto size_output = model_recipe.output_size();
-    for (int co = 0; co < size_output; ++co)
-    {
-      tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-      buffer_vec.emplace_back(buffer_builder.Finish());
+      dims = as_dims(operand.shape());
+      shape = flatbuffer_builder->CreateVector(dims);
     }
 
-    // default name for main graph
-    std::string graph_name = "main";
-    if (model_recipe.has_name())
-      graph_name = model_recipe.name();
+    auto name = flatbuffer_builder->CreateString(operand.name());
 
-    auto input_names = as_dataset(model_recipe.input()).vectorize();
-    auto output_names = as_dataset(model_recipe.output()).vectorize();
+    buffer_index = 0;
 
-    for (const auto &operand : model_recipe.operand())
+    // Create Buffer if filler is specified
+    if (operand.has_filler())
     {
-      assert(operand.has_name());
-
-      assert(operand.has_type());
-      assert(operand.has_shape());
-
-      std::vector<int32_t> dims = as_dims(operand.shape());
-
-      auto shape = flatbuffer_builder->CreateVector(dims);
-      auto name = flatbuffer_builder->CreateString(operand.name());
-
-      buffer_index = 0;
-
-      // Create Buffer if filler is specified
-      if (operand.has_filler())
-      {
-        const auto &filler = operand.filler();
+      const auto &filler = operand.filler();
 
-        assert(filler.has_tag());
+      assert(filler.has_tag());
 
-        auto args = ranged_arguments(filler.arg().begin(), filler.arg().end());
-        auto chef = data_chef_registry(operand.type()).lookup(filler.tag()).create(args);
+      auto args = ranged_arguments(filler.arg().begin(), filler.arg().end());
+      auto chef = data_chef_registry(operand.type()).lookup(filler.tag()).create(args);
 
-        assert(chef != nullptr);
+      assert(chef != nullptr);
 
-        // Create Data
-        auto data_vec = chef->generate(element_count(dims));
-        auto data = flatbuffer_builder->CreateVector(data_vec);
+      // Create Data
+      int32_t count = (element_count(dims) > 0) ? element_count(dims) : filler.arg_size();
+      auto data_vec = chef->generate(count);
+      auto data = flatbuffer_builder->CreateVector(data_vec);
 
-        // Create Buffer
-        tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-        buffer_builder.add_data(data);
-        auto buffer = buffer_builder.Finish();
+      // Create Buffer
+      tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
+      buffer_builder.add_data(data);
+      auto buffer = buffer_builder.Finish();
 
-        // Update Buffer Index & Vector
-        buffer_index = buffer_vec.size();
-        buffer_vec.emplace_back(buffer);
+      // Update Buffer Index & Vector
+      buffer_index = buffer_vec.size();
+      buffer_vec.emplace_back(buffer);
+    }
+    else
+    {
+      // if this is input or output, assign to that buffer_index
+      int idx = 0;
+      for (auto it = input_names.begin(); it != input_names.end(); ++it, ++idx)
+      {
+        if (*it == operand.name())
+        {
+          buffer_index = buffer_start + idx;
+          break;
+        }
       }
-      else
+      if (buffer_index == 0)
       {
-        // if this is input or output, assign to that buffer_index
-        int idx = 0;
-        for (auto it = input_names.begin(); it != input_names.end(); ++it, ++idx)
+        idx = 0;
+        for (auto it = output_names.begin(); it != output_names.end(); ++it, ++idx)
         {
           if (*it == operand.name())
           {
-            buffer_index = buffer_start + idx;
+            buffer_index = buffer_start + size_input + idx;
             break;
           }
         }
-        if (buffer_index == 0)
-        {
-          idx = 0;
-          for (auto it = output_names.begin(); it != output_names.end(); ++it, ++idx)
-          {
-            if (*it == operand.name())
-            {
-              buffer_index = buffer_start + size_input + idx;
-              break;
-            }
-          }
-        }
       }
-
-      flatbuffers::Offset<tflite::QuantizationParameters> quant_index;
-
-      // Create QuantizationParameters if quant is specified
-      if (operand.has_quant())
+      if (buffer_index == 0)
       {
-        const auto &quant = operand.quant();
-
-        // Create each parameters
-        // NOTE if some parameters are not given, those will be set to default value
-        std::vector<float> quant_max_vec(quant.max_size());
-        std::vector<float> quant_min_vec(quant.min_size());
-        std::vector<float> quant_scale_vec(quant.scale_size());
-        std::vector<int64_t> quant_zero_point_vec(quant.zero_point_size());
-
-        for (uint32_t i = 0; i < quant.max_size(); ++i)
-          quant_max_vec.at(i) = quant.max(i);
-        for (uint32_t i = 0; i < quant.min_size(); ++i)
-          quant_min_vec.at(i) = quant.min(i);
-        for (uint32_t i = 0; i < quant.scale_size(); ++i)
-          quant_scale_vec.at(i) = quant.scale(i);
-        for (uint32_t i = 0; i < quant.zero_point_size(); ++i)
-          quant_zero_point_vec.at(i) = quant.zero_point(i);
-
-        auto quant_max = flatbuffer_builder->CreateVector(quant_max_vec);
-        auto quant_min = flatbuffer_builder->CreateVector(quant_min_vec);
-        auto quant_scale = flatbuffer_builder->CreateVector(quant_scale_vec);
-        auto quant_zero_point = flatbuffer_builder->CreateVector(quant_zero_point_vec);
-
-        // Create QuantizationParameters
-        tflite::QuantizationParametersBuilder quant_builder{*flatbuffer_builder};
-        quant_builder.add_max(quant_max);
-        quant_builder.add_min(quant_min);
-        quant_builder.add_scale(quant_scale);
-        quant_builder.add_zero_point(quant_zero_point);
-
-        // Update QuantizationParameters Index
-        quant_index = quant_builder.Finish();
-      }
-
-      // Create Tensor
-      tflite::TensorBuilder tensor_builder{*flatbuffer_builder};
-
-      tensor_builder.add_shape(shape);
-      tensor_builder.add_type(as_tflite_tensortype(operand.type()));
-      tensor_builder.add_buffer(buffer_index);
-      tensor_builder.add_name(name);
-      if (operand.has_quant())
-        tensor_builder.add_quantization(quant_index);
-
-      // Append!
-      tensor_vec.emplace_back(tensor_builder.Finish());
-
-      // Update Tensor Name -> Tensor Index Map
-      int32_t tensor_index = symbol_table.size();
-      const auto &tensor_name = operand.name();
+        // we couldn't find the buffer; create an empty buffer for this tensor
+        buffer_index = buffer_vec.size();
 
-      symbol_table[tensor_name] = tensor_index;
+        tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
+        buffer_vec.emplace_back(buffer_builder.Finish());
+      }
     }
+    assert(buffer_index != 0);
 
-    // Create Operator
-    for (const auto &operation : model_recipe.operation())
-    {
-      assert(operation.has_type());
-
-      auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
-
-      // Create 'inputs'
-      std::vector<int32_t> input_vec = as_dataset(operation.input()).map(lookup).vectorize();
-      auto inputs = flatbuffer_builder->CreateVector(input_vec);
-
-      // Create 'outputs'
-      std::vector<int32_t> output_vec = as_dataset(operation.output()).map(lookup).vectorize();
-      auto outputs = flatbuffer_builder->CreateVector(output_vec);
-
-      // Create Option
-      auto options = op_chef->value(*flatbuffer_builder);
-
-      // Create Operator
-      tflite::OperatorBuilder op_builder{*flatbuffer_builder};
-
-      // Get operator code index from opcode_set with assumption, order of
-      // opcode_set is same as that of code_vec
-      auto op_it = opcode_set.find(op_chef->code());
-      assert(op_it != opcode_set.end());
-      uint32_t opcode_index = std::distance(opcode_set.begin(), op_it);
-
-      op_builder.add_opcode_index(opcode_index);
-      op_builder.add_inputs(inputs);
-      op_builder.add_outputs(outputs);
-      op_builder.add_builtin_options_type(op_chef->type());
-      op_builder.add_builtin_options(options);
+    flatbuffers::Offset<tflite::QuantizationParameters> quant_index;
 
-      // Append Operator
-      operator_vec.emplace_back(op_builder.Finish());
+    // Create QuantizationParameters if quant is specified
+    if (operand.has_quant())
+    {
+      const auto &quant = operand.quant();
+
+      // Create each parameters
+      // NOTE if some parameters are not given, those will be set to default value
+      std::vector<float> quant_max_vec(quant.max_size());
+      std::vector<float> quant_min_vec(quant.min_size());
+      std::vector<float> quant_scale_vec(quant.scale_size());
+      std::vector<int64_t> quant_zero_point_vec(quant.zero_point_size());
+
+      for (uint32_t i = 0; i < quant.max_size(); ++i)
+        quant_max_vec.at(i) = quant.max(i);
+      for (uint32_t i = 0; i < quant.min_size(); ++i)
+        quant_min_vec.at(i) = quant.min(i);
+      for (uint32_t i = 0; i < quant.scale_size(); ++i)
+        quant_scale_vec.at(i) = quant.scale(i);
+      for (uint32_t i = 0; i < quant.zero_point_size(); ++i)
+        quant_zero_point_vec.at(i) = quant.zero_point(i);
+
+      auto quant_max = flatbuffer_builder->CreateVector(quant_max_vec);
+      auto quant_min = flatbuffer_builder->CreateVector(quant_min_vec);
+      auto quant_scale = flatbuffer_builder->CreateVector(quant_scale_vec);
+      auto quant_zero_point = flatbuffer_builder->CreateVector(quant_zero_point_vec);
+
+      // Create QuantizationParameters
+      tflite::QuantizationParametersBuilder quant_builder{*flatbuffer_builder};
+      quant_builder.add_max(quant_max);
+      quant_builder.add_min(quant_min);
+      quant_builder.add_scale(quant_scale);
+      quant_builder.add_zero_point(quant_zero_point);
+
+      // Update QuantizationParameters Index
+      quant_index = quant_builder.Finish();
     }
 
-    // Create network input/output vector
-    std::vector<int32_t> input_vec = as_dataset(model_recipe.input()).map(lookup).vectorize();
-    std::vector<int32_t> output_vec = as_dataset(model_recipe.output()).map(lookup).vectorize();
+    // Create Tensor
+    tflite::TensorBuilder tensor_builder{*flatbuffer_builder};
 
-    // Create "SubGraph" arguments
-    auto tensors = flatbuffer_builder->CreateVector(tensor_vec);
-    auto inputs = flatbuffer_builder->CreateVector(input_vec);
-    auto outputs = flatbuffer_builder->CreateVector(output_vec);
-    auto operators = flatbuffer_builder->CreateVector(operator_vec);
-    auto name = flatbuffer_builder->CreateString(graph_name);
+    tensor_builder.add_shape(shape);
+    tensor_builder.add_type(as_tflite_tensortype(operand.type()));
+    tensor_builder.add_buffer(buffer_index);
+    tensor_builder.add_name(name);
+    if (operand.has_quant())
+      tensor_builder.add_quantization(quant_index);
+
+    // Append!
+    tensor_vec.emplace_back(tensor_builder.Finish());
 
-    tflite::SubGraphBuilder subgraph_builder{*flatbuffer_builder};
+    // Update Tensor Name -> Tensor Index Map
+    int32_t tensor_index = symbol_table.size();
+    const auto &tensor_name = operand.name();
 
-    subgraph_builder.add_tensors(tensors);
-    subgraph_builder.add_inputs(inputs);
-    subgraph_builder.add_outputs(outputs);
-    subgraph_builder.add_operators(operators);
-    subgraph_builder.add_name(name);
+    INFO(l) << "Symbol [" << tensor_name << "] = Tensor " << tensor_index << std::endl;
 
-    subgraph_vec.emplace_back(subgraph_builder.Finish());
+    symbol_table[tensor_name] = tensor_index;
   }
 
-  //
-  // Create subgraphs if exist
-  // TODO refactor main graph and subgraphs generation to reduce duplicate codes
-  //
-  for (int g = 0; g < model_recipe.graph_size(); ++g)
+  // Create Operator
+  for (const auto &operation : graph.operation())
   {
-    // Operand-related
-    std::vector<flatbuffers::Offset<::tflite::Tensor>> tensor_vec;
-
-    // Operation-related
-    std::vector<flatbuffers::Offset<::tflite::Operator>> operator_vec;
-
-    // Tensor Name -> Tensor ID mapping (per Graph)
-    std::map<std::string, int32_t> symbol_table;
-
-    auto lookup = [&symbol_table](const std::string &name) { return symbol_table.at(name); };
-
-    const auto &graph = model_recipe.graph(g);
-
-    int32_t buffer_start = buffer_vec.size();
-    int32_t buffer_index = 0;
-
-    // Create buffer(s) for input(s)
-    const auto size_input = graph.input_size();
-    for (int ci = 0; ci < size_input; ++ci)
-    {
-      tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-      buffer_vec.emplace_back(buffer_builder.Finish());
-    }
-    // Create buffer(s) for output(s)
-    const auto size_output = graph.output_size();
-    for (int co = 0; co < size_output; ++co)
-    {
-      tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-      buffer_vec.emplace_back(buffer_builder.Finish());
-    }
-
-    // default name for sub graph
-    // TODO naming rule here may have conflit if recipe file provides it.
-    //      fix this when this happens.
-    std::ostringstream stringStream;
-    stringStream << "sub_" << (g + 1);
-    std::string graph_name = stringStream.str();
-    if (graph.has_name())
-      graph_name = graph.name();
+    assert(operation.has_type());
 
-    auto input_names = as_dataset(graph.input()).vectorize();
-    auto output_names = as_dataset(graph.output()).vectorize();
-
-    for (const auto &operand : graph.operand())
-    {
-      assert(operand.has_name());
-
-      assert(operand.has_type());
-      assert(operand.has_shape());
-
-      std::vector<int32_t> dims = as_dims(operand.shape());
-
-      auto shape = flatbuffer_builder->CreateVector(dims);
-      auto name = flatbuffer_builder->CreateString(operand.name());
+    auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
 
-      // Create Buffer if filler is specified
-      if (operand.has_filler())
-      {
-        const auto &filler = operand.filler();
+    // Create 'inputs'
+    std::vector<int32_t> input_vec = as_dataset(operation.input()).map(lookup).vectorize();
+    auto inputs = flatbuffer_builder->CreateVector(input_vec);
 
-        assert(filler.has_tag());
+    // Create 'outputs'
+    std::vector<int32_t> output_vec = as_dataset(operation.output()).map(lookup).vectorize();
+    auto outputs = flatbuffer_builder->CreateVector(output_vec);
 
-        auto args = ranged_arguments(filler.arg().begin(), filler.arg().end());
-        auto chef = data_chef_registry(operand.type()).lookup(filler.tag()).create(args);
+    // Create Option
+    auto options = op_chef->value(*flatbuffer_builder);
 
-        assert(chef != nullptr);
+    // Create Custom option
+    auto circle_custom_options = op_chef->custom_value(*flatbuffer_builder);
 
-        // Create Data
-        auto data_vec = chef->generate(element_count(dims));
-        auto data = flatbuffer_builder->CreateVector(data_vec);
+    // Create Operator
+    tflite::OperatorBuilder op_builder{*flatbuffer_builder};
+
+    // Get operator code index from builtin_code_set with assumption, order of
+    // builtin_code_set is same as that of code_vec
+    auto op_it = builtin_code_map.find(op_chef->code());
+    assert(op_it != builtin_code_map.end());
+    uint32_t opcode_index = std::distance(builtin_code_map.begin(), op_it);
+
+    op_builder.add_opcode_index(opcode_index);
+    op_builder.add_inputs(inputs);
+    op_builder.add_outputs(outputs);
+    op_builder.add_builtin_options_type(op_chef->type());
+    op_builder.add_builtin_options(options);
+    op_builder.add_custom_options(circle_custom_options);
+    op_builder.add_custom_options_format(tflite::CustomOptionsFormat_FLEXBUFFERS);
+    // Append Operator
+    operator_vec.emplace_back(op_builder.Finish());
+  }
 
-        // Create Buffer
-        tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
-        buffer_builder.add_data(data);
-        auto buffer = buffer_builder.Finish();
+  // Create network input/output vector
+  std::vector<int32_t> input_vec = as_dataset(graph.input()).map(lookup).vectorize();
+  std::vector<int32_t> output_vec = as_dataset(graph.output()).map(lookup).vectorize();
 
-        // Update Buffer Index & Vector
-        buffer_index = buffer_vec.size();
-        buffer_vec.emplace_back(buffer);
-      }
-      else
-      {
-        // if this is input or output, assign to that buffer_index
-        int idx = 0;
-        buffer_index = 0;
-        for (auto it = input_names.begin(); it != input_names.end(); ++it, ++idx)
-        {
-          if (*it == operand.name())
-          {
-            buffer_index = buffer_start + idx;
-            break;
-          }
-        }
-        if (buffer_index == 0)
-        {
-          idx = 0;
-          for (auto it = output_names.begin(); it != output_names.end(); ++it, ++idx)
-          {
-            if (*it == operand.name())
-            {
-              buffer_index = buffer_start + size_input + idx;
-              break;
-            }
-          }
-        }
-      }
-      // NOTE buffer_index can be 0 when this operand does not have a filler or not I/O
+  // Create "SubGraph" arguments
+  auto tensors = flatbuffer_builder->CreateVector(tensor_vec);
+  auto inputs = flatbuffer_builder->CreateVector(input_vec);
+  auto outputs = flatbuffer_builder->CreateVector(output_vec);
+  auto operators = flatbuffer_builder->CreateVector(operator_vec);
+  auto name = flatbuffer_builder->CreateString(graph_name);
 
-      flatbuffers::Offset<tflite::QuantizationParameters> quant_index;
+  tflite::SubGraphBuilder subgraph_builder{*flatbuffer_builder};
 
-      // Create QuantizationParameters if quant is specified
-      if (operand.has_quant())
-      {
-        const auto &quant = operand.quant();
-
-        // Create each parameters
-        // NOTE if some parameters are not given, those will be set to default value
-        std::vector<float> quant_max_vec(quant.max_size());
-        std::vector<float> quant_min_vec(quant.min_size());
-        std::vector<float> quant_scale_vec(quant.scale_size());
-        std::vector<int64_t> quant_zero_point_vec(quant.zero_point_size());
-
-        for (uint32_t i = 0; i < quant.max_size(); ++i)
-          quant_max_vec.at(i) = quant.max(i);
-        for (uint32_t i = 0; i < quant.min_size(); ++i)
-          quant_min_vec.at(i) = quant.min(i);
-        for (uint32_t i = 0; i < quant.scale_size(); ++i)
-          quant_scale_vec.at(i) = quant.scale(i);
-        for (uint32_t i = 0; i < quant.zero_point_size(); ++i)
-          quant_zero_point_vec.at(i) = quant.zero_point(i);
-
-        auto quant_max = flatbuffer_builder->CreateVector(quant_max_vec);
-        auto quant_min = flatbuffer_builder->CreateVector(quant_min_vec);
-        auto quant_scale = flatbuffer_builder->CreateVector(quant_scale_vec);
-        auto quant_zero_point = flatbuffer_builder->CreateVector(quant_zero_point_vec);
-
-        // Create QuantizationParameters
-        tflite::QuantizationParametersBuilder quant_builder{*flatbuffer_builder};
-        quant_builder.add_max(quant_max);
-        quant_builder.add_min(quant_min);
-        quant_builder.add_scale(quant_scale);
-        quant_builder.add_zero_point(quant_zero_point);
-
-        // Update QuantizationParameters Index
-        quant_index = quant_builder.Finish();
-      }
+  subgraph_builder.add_tensors(tensors);
+  subgraph_builder.add_inputs(inputs);
+  subgraph_builder.add_outputs(outputs);
+  subgraph_builder.add_operators(operators);
+  subgraph_builder.add_name(name);
 
-      // Create Tensor
-      tflite::TensorBuilder tensor_builder{*flatbuffer_builder};
+  subgraph_vec.emplace_back(subgraph_builder.Finish());
+}
 
-      tensor_builder.add_shape(shape);
-      tensor_builder.add_type(as_tflite_tensortype(operand.type()));
-      tensor_builder.add_buffer(buffer_index);
-      tensor_builder.add_name(name);
-      if (operand.has_quant())
-        tensor_builder.add_quantization(quant_index);
+} // namespace
 
-      // Append!
-      tensor_vec.emplace_back(tensor_builder.Finish());
+namespace tflchef
+{
 
-      // Update Tensor Name -> Tensor Index Map
-      int32_t tensor_index = symbol_table.size();
-      const auto &tensor_name = operand.name();
+/**
+ * @brief Generate a (in-memory) TensorFlow Lite model from a given model recipe
+ */
+GeneratedModel cook(const ::tflchef::ModelRecipe &model_recipe)
+{
+// Initialize Op Chef Registry
+#define OP_CHEF(NAME, FACTORY_CLASS) \
+  op_chef_registry().add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
+#include "OpChef.def"
+#undef OP_CHEF
 
-      symbol_table[tensor_name] = tensor_index;
-    }
+// Initialize Data Chef Registry
+#define DATA_CHEF(TYPE, NAME, FACTORY_CLASS) \
+  data_chef_registry(::tflchef::TYPE)        \
+      .add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
+#include <souschef/DataChef.def>
+#undef DATA_CHEF
 
-    // Create Operator
-    for (const auto &operation : graph.operation())
-    {
-      assert(operation.has_type());
+  //
+  // Create FlatBufferBuilder
+  //
+  auto flatbuffer_builder =
+      std::unique_ptr<flatbuffers::FlatBufferBuilder>(new flatbuffers::FlatBufferBuilder(1024));
 
-      auto op_chef = op_chef_registry().lookup(operation.type()).create(&operation);
+  // Operand-related
+  std::vector<flatbuffers::Offset<::tflite::Buffer>> buffer_vec;
 
-      // Create 'inputs'
-      std::vector<int32_t> input_vec = as_dataset(operation.input()).map(lookup).vectorize();
-      auto inputs = flatbuffer_builder->CreateVector(input_vec);
+  // Operation-related
+  std::vector<flatbuffers::Offset<::tflite::OperatorCode>> code_vec;
 
-      // Create 'outputs'
-      std::vector<int32_t> output_vec = as_dataset(operation.output()).map(lookup).vectorize();
-      auto outputs = flatbuffer_builder->CreateVector(output_vec);
+  // Graphs-related
+  std::vector<flatbuffers::Offset<::tflite::SubGraph>> subgraph_vec;
 
-      // Create Option
-      auto options = op_chef->value(*flatbuffer_builder);
+  // Create OperatorCode with Builtin Operator
+  auto builtin_code_map = gather_builtincode_map(model_recipe);
+  for (auto const &opcode : builtin_code_map)
+  {
+    tflite::OperatorCodeBuilder code_builder{*flatbuffer_builder};
+    code_builder.add_builtin_code(opcode.first);
+    code_builder.add_version(opcode.second);
+    auto code = code_builder.Finish();
+    // Update OperatorCode vector
+    code_vec.emplace_back(code);
+  }
 
-      // Create Operator
-      tflite::OperatorBuilder op_builder{*flatbuffer_builder};
+  // Create OperatorCode with Custom Operator
+  std::set<std::string> custom_code_set = gather_customcode_set(model_recipe);
+  if (custom_code_set.size() &&
+      builtin_code_map.find(tflite::BuiltinOperator_CUSTOM) == builtin_code_map.end())
+    builtin_code_map[tflite::BuiltinOperator_CUSTOM] = 1;
 
-      // Get operator code index from opcode_set with assumption, order of
-      // opcode_set is same as that of code_vec
-      auto op_it = opcode_set.find(op_chef->code());
-      assert(op_it != opcode_set.end());
-      uint32_t opcode_index = std::distance(opcode_set.begin(), op_it);
+  for (auto opcode : custom_code_set)
+  {
+    auto custom_code = flatbuffer_builder->CreateString(opcode);
+    tflite::OperatorCodeBuilder code_builder{*flatbuffer_builder};
+    code_builder.add_builtin_code(tflite::BuiltinOperator_CUSTOM);
+    code_builder.add_custom_code(custom_code);
+    auto code = code_builder.Finish();
+    // Update OperatorCode vector
+    code_vec.emplace_back(code);
+  }
 
-      op_builder.add_opcode_index(opcode_index);
-      op_builder.add_inputs(inputs);
-      op_builder.add_outputs(outputs);
-      op_builder.add_builtin_options_type(op_chef->type());
-      op_builder.add_builtin_options(options);
+  // Create an Empty Buffer
+  //
+  // Buffer 0 SHOULD be an empty buffer in TensorFlow Lite model file
+  // (Please refer to the comment for Tensor.buffer field in schema)
+  {
+    tflite::BufferBuilder buffer_builder{*flatbuffer_builder};
+    buffer_vec.emplace_back(buffer_builder.Finish());
+  }
 
-      // Append Operator
-      operator_vec.emplace_back(op_builder.Finish());
-    }
+  //
+  // Create Main graph
+  //
+  CookParams cp{buffer_vec, code_vec, subgraph_vec, flatbuffer_builder, builtin_code_map, "main"};
 
-    // Create network input/output vector
-    std::vector<int32_t> input_vec = as_dataset(graph.input()).map(lookup).vectorize();
-    std::vector<int32_t> output_vec = as_dataset(graph.output()).map(lookup).vectorize();
+  cook_graph<::tflchef::ModelRecipe>(model_recipe, cp);
 
-    // Create "SubGraph" arguments
-    auto tensors = flatbuffer_builder->CreateVector(tensor_vec);
-    auto inputs = flatbuffer_builder->CreateVector(input_vec);
-    auto outputs = flatbuffer_builder->CreateVector(output_vec);
-    auto operators = flatbuffer_builder->CreateVector(operator_vec);
-    auto name = flatbuffer_builder->CreateString(graph_name);
+  //
+  // Create subgraphs if exist
+  //
+  for (int g = 0; g < model_recipe.graph_size(); ++g)
+  {
+    const auto &graph = model_recipe.graph(g);
 
-    tflite::SubGraphBuilder subgraph_builder{*flatbuffer_builder};
+    std::ostringstream stringStream;
+    stringStream << "sub_" << (g + 1);
 
-    subgraph_builder.add_tensors(tensors);
-    subgraph_builder.add_inputs(inputs);
-    subgraph_builder.add_outputs(outputs);
-    subgraph_builder.add_operators(operators);
-    subgraph_builder.add_name(name);
+    CookParams cp{buffer_vec,         code_vec,         subgraph_vec,
+                  flatbuffer_builder, builtin_code_map, stringStream.str()};
 
-    subgraph_vec.emplace_back(subgraph_builder.Finish());
+    cook_graph<::tflchef::Graph>(graph, cp);
   }
 
   // Create "Model" arguments
diff --git a/compiler/tflchef/core/src/Op/AddN.cpp b/compiler/tflchef/core/src/Op/AddN.cpp
new file mode 100644
index 000000000..2ac02d219
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/AddN.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AddN.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> AddNChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::AddNOptionsBuilder add_n_options_builder{fbb};
+
+  return add_n_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> AddNChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new AddNChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/AddN.h b/compiler/tflchef/core/src/Op/AddN.h
new file mode 100644
index 000000000..44dcc63ef
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/AddN.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ADD_N_H__
+#define __OP_ADD_N_H__
+
+#include "OpChef.h"
+
+class AddNChef final : public OpChef
+{
+public:
+  explicit AddNChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ADD_N; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_AddNOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct AddNChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ADD_N_H__
diff --git a/compiler/tflchef/core/src/Op/ArgMin.cpp b/compiler/tflchef/core/src/Op/ArgMin.cpp
new file mode 100644
index 000000000..b599270b0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ArgMin.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ArgMin.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ArgMinChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_argmin_options());
+
+  auto tflite_output_type = as_tflite_tensortype(operation.argmin_options().output_type());
+
+  tflite::ArgMinOptionsBuilder argmin_options_builder{fbb};
+  argmin_options_builder.add_output_type(tflite_output_type);
+
+  return argmin_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ArgMinChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ArgMinChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ArgMin.h b/compiler/tflchef/core/src/Op/ArgMin.h
new file mode 100644
index 000000000..222039f91
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ArgMin.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ARGMIN_H__
+#define __OP_ARGMIN_H__
+
+#include "OpChef.h"
+
+class ArgMinChef final : public OpChef
+{
+public:
+  explicit ArgMinChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ARG_MIN; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ArgMinOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ArgMinChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ARGMIN_H__
diff --git a/compiler/tflchef/core/src/Op/BatchMatMul.cpp b/compiler/tflchef/core/src/Op/BatchMatMul.cpp
new file mode 100644
index 000000000..7722bcc5e
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/BatchMatMul.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BatchMatMul.h"
+
+flatbuffers::Offset<void> BatchMatMulChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_batch_matmul_options());
+
+  tflite::BatchMatMulOptionsBuilder batch_matmul_options_options_builder{fbb};
+  batch_matmul_options_options_builder.add_adj_x(operation.batch_matmul_options().adj_x());
+  batch_matmul_options_options_builder.add_adj_y(operation.batch_matmul_options().adj_y());
+
+  return batch_matmul_options_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> BatchMatMulChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new BatchMatMulChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/BatchMatMul.h b/compiler/tflchef/core/src/Op/BatchMatMul.h
new file mode 100644
index 000000000..eaf943cb0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/BatchMatMul.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_BATCH_MATMUL_H__
+#define __OP_BATCH_MATMUL_H__
+
+#include "OpChef.h"
+
+class BatchMatMulChef final : public OpChef
+{
+public:
+  explicit BatchMatMulChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_BATCH_MATMUL; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_BatchMatMulOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct BatchMatMulChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_BATCH_MATMUL_H__
diff --git a/compiler/tflchef/core/src/Op/Cast.cpp b/compiler/tflchef/core/src/Op/Cast.cpp
new file mode 100644
index 000000000..1a29f9ac4
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Cast.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Cast.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> CastChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  if (!operation.has_cast_options())
+    return 0;
+
+  auto tflite_in_data_type = as_tflite_tensortype(operation.cast_options().in_data_type());
+  auto tflite_out_data_type = as_tflite_tensortype(operation.cast_options().out_data_type());
+
+  tflite::CastOptionsBuilder cast_options_builder{fbb};
+  cast_options_builder.add_in_data_type(tflite_in_data_type);
+  cast_options_builder.add_out_data_type(tflite_out_data_type);
+
+  return cast_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> CastChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new CastChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Cast.h b/compiler/tflchef/core/src/Op/Cast.h
new file mode 100644
index 000000000..84c8e29e4
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Cast.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_CAST_H__
+#define __OP_CAST_H__
+
+#include "OpChef.h"
+
+class CastChef final : public OpChef
+{
+public:
+  explicit CastChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CAST; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_CastOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct CastChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_CAST_H__
diff --git a/compiler/tflchef/core/src/Op/Ceil.cpp b/compiler/tflchef/core/src/Op/Ceil.cpp
new file mode 100644
index 000000000..3da047727
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Ceil.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Ceil.h"
+
+flatbuffers::Offset<void> CeilChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Ceil. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> CeilChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new CeilChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Ceil.h b/compiler/tflchef/core/src/Op/Ceil.h
new file mode 100644
index 000000000..5a42b7f00
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Ceil.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_CEIL_H__
+#define __OP_CEIL_H__
+
+#include "OpChef.h"
+
+class CeilChef final : public OpChef
+{
+public:
+  explicit CeilChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_CEIL; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct CeilChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_CEIL_H__
diff --git a/compiler/tflchef/core/src/Op/Conv2D.cpp b/compiler/tflchef/core/src/Op/Conv2D.cpp
index d99c53351..0b3ef8a6d 100644
--- a/compiler/tflchef/core/src/Op/Conv2D.cpp
+++ b/compiler/tflchef/core/src/Op/Conv2D.cpp
@@ -25,14 +25,18 @@ flatbuffers::Offset<void> Conv2DChef::value(flatbuffers::FlatBufferBuilder &fbb)
 
   assert(operation.has_conv2d_options());
 
-  auto tflite_padding = as_tflite_padding(operation.conv2d_options().padding());
-  auto tflite_activation = as_tflite_activation(operation.conv2d_options().activation());
+  const auto &conv2d_options = operation.conv2d_options();
+
+  auto tflite_padding = as_tflite_padding(conv2d_options.padding());
+  auto tflite_activation = as_tflite_activation(conv2d_options.activation());
 
   tflite::Conv2DOptionsBuilder conv2d_options_builder{fbb};
   conv2d_options_builder.add_padding(tflite_padding);
-  conv2d_options_builder.add_stride_h(operation.conv2d_options().stride_h());
-  conv2d_options_builder.add_stride_w(operation.conv2d_options().stride_w());
+  conv2d_options_builder.add_stride_h(conv2d_options.stride_h());
+  conv2d_options_builder.add_stride_w(conv2d_options.stride_w());
   conv2d_options_builder.add_fused_activation_function(tflite_activation);
+  conv2d_options_builder.add_dilation_w_factor(conv2d_options.dilation_w_factor());
+  conv2d_options_builder.add_dilation_h_factor(conv2d_options.dilation_h_factor());
 
   return conv2d_options_builder.Finish().Union();
 }
diff --git a/compiler/tflchef/core/src/Op/DepthToSpace.cpp b/compiler/tflchef/core/src/Op/DepthToSpace.cpp
new file mode 100644
index 000000000..f0531d98d
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/DepthToSpace.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "DepthToSpace.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> DepthToSpaceChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_depth_to_space_options());
+
+  auto options = operation.depth_to_space_options();
+
+  auto tflite_block_size = options.block_size();
+
+  tflite::DepthToSpaceOptionsBuilder options_builder{fbb};
+
+  options_builder.add_block_size(tflite_block_size);
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> DepthToSpaceChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new DepthToSpaceChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/DepthToSpace.h b/compiler/tflchef/core/src/Op/DepthToSpace.h
new file mode 100644
index 000000000..32cb24211
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/DepthToSpace.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_DEPTHTOSPACE_H__
+#define __OP_DEPTHTOSPACE_H__
+
+#include "OpChef.h"
+
+class DepthToSpaceChef final : public OpChef
+{
+public:
+  explicit DepthToSpaceChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_DEPTH_TO_SPACE;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_DepthToSpaceOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct DepthToSpaceChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_DEPTHTOSPACE_H__
diff --git a/compiler/tflchef/core/src/Op/DepthwiseConv2D.cpp b/compiler/tflchef/core/src/Op/DepthwiseConv2D.cpp
index e04cf50ff..5da5b63e4 100644
--- a/compiler/tflchef/core/src/Op/DepthwiseConv2D.cpp
+++ b/compiler/tflchef/core/src/Op/DepthwiseConv2D.cpp
@@ -36,6 +36,8 @@ flatbuffers::Offset<void> DepthwiseConv2DChef::value(flatbuffers::FlatBufferBuil
   options_builder.add_stride_h(options.stride_h());
   options_builder.add_depth_multiplier(options.depth_multiplier());
   options_builder.add_fused_activation_function(tflite_activation);
+  options_builder.add_dilation_w_factor(options.dilation_w_factor());
+  options_builder.add_dilation_h_factor(options.dilation_h_factor());
 
   return options_builder.Finish().Union();
 }
diff --git a/compiler/tflchef/core/src/Op/ELU.cpp b/compiler/tflchef/core/src/Op/ELU.cpp
new file mode 100644
index 000000000..d9dae16af
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ELU.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELU.h"
+
+flatbuffers::Offset<void> ELUChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> ELUChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ELUChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ELU.h b/compiler/tflchef/core/src/Op/ELU.h
new file mode 100644
index 000000000..e164c0071
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ELU.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ELU_H__
+#define __OP_ELU_H__
+
+#include "OpChef.h"
+
+class ELUChef final : public OpChef
+{
+public:
+  explicit ELUChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ELU; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ELUChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ELU_H__
diff --git a/compiler/tflchef/core/src/Op/ExpandDims.cpp b/compiler/tflchef/core/src/Op/ExpandDims.cpp
new file mode 100644
index 000000000..c6082811f
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ExpandDims.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ExpandDims.h"
+#include "Convert.h"
+
+flatbuffers::Offset<void> ExpandDimsChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::ExpandDimsOptionsBuilder expand_dims_options_builder{fbb};
+
+  return expand_dims_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ExpandDimsChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ExpandDimsChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ExpandDims.h b/compiler/tflchef/core/src/Op/ExpandDims.h
new file mode 100644
index 000000000..1f4c34a98
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ExpandDims.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_EXPAND_DIMS_H__
+#define __OP_EXPAND_DIMS_H__
+
+#include "OpChef.h"
+
+class ExpandDimsChef final : public OpChef
+{
+public:
+  explicit ExpandDimsChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_EXPAND_DIMS; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ExpandDimsOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ExpandDimsChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_EXPAND_DIMS_H__
diff --git a/compiler/tflchef/core/src/Op/Fill.cpp b/compiler/tflchef/core/src/Op/Fill.cpp
new file mode 100644
index 000000000..4a6829459
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Fill.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Fill.h"
+
+#include <cassert>
+#include <vector>
+
+flatbuffers::Offset<void> FillChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::FillOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> FillChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new FillChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Fill.h b/compiler/tflchef/core/src/Op/Fill.h
new file mode 100644
index 000000000..60f9084c8
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Fill.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_FILL_H__
+#define __OP_FILL_H__
+
+#include "OpChef.h"
+
+class FillChef final : public OpChef
+{
+public:
+  explicit FillChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_FILL; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_FillOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct FillChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_FILL_H__
diff --git a/compiler/tflchef/core/src/Op/Floor.cpp b/compiler/tflchef/core/src/Op/Floor.cpp
new file mode 100644
index 000000000..8f6820152
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Floor.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Floor.h"
+
+flatbuffers::Offset<void> FloorChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Floor. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> FloorChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new FloorChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Floor.h b/compiler/tflchef/core/src/Op/Floor.h
new file mode 100644
index 000000000..23385d737
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Floor.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_FLOOR_H__
+#define __OP_FLOOR_H__
+
+#include "OpChef.h"
+
+class FloorChef final : public OpChef
+{
+public:
+  explicit FloorChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_FLOOR; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct FloorChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_FLOOR_H__
diff --git a/compiler/tflchef/core/src/Op/FloorMod.cpp b/compiler/tflchef/core/src/Op/FloorMod.cpp
new file mode 100644
index 000000000..d17795a72
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/FloorMod.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FloorMod.h"
+
+flatbuffers::Offset<void> FloorModChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::FloorModOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> FloorModChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new FloorModChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/FloorMod.h b/compiler/tflchef/core/src/Op/FloorMod.h
new file mode 100644
index 000000000..b501f61e0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/FloorMod.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_FLOOR_MOD_H__
+#define __OP_FLOOR_MOD_H__
+
+#include "OpChef.h"
+
+class FloorModChef final : public OpChef
+{
+public:
+  explicit FloorModChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_FLOOR_MOD; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_FloorModOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct FloorModChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_FLOOR_MOD_H__
diff --git a/compiler/tflchef/core/src/Op/Gather.cpp b/compiler/tflchef/core/src/Op/Gather.cpp
new file mode 100644
index 000000000..2b62c7be2
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Gather.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Gather.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> GatherChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_gather_options());
+
+  auto options = operation.gather_options();
+
+  tflite::GatherOptionsBuilder options_builder{fbb};
+
+  options_builder.add_axis(options.axis());
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> GatherChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new GatherChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Gather.h b/compiler/tflchef/core/src/Op/Gather.h
new file mode 100644
index 000000000..d937178c8
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Gather.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_GATHER_H__
+#define __OP_GATHER_H__
+
+#include "OpChef.h"
+
+class GatherChef final : public OpChef
+{
+public:
+  explicit GatherChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_GATHER; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_GatherOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct GatherChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_GATHER_H__
diff --git a/compiler/tflchef/core/src/Op/GatherNd.cpp b/compiler/tflchef/core/src/Op/GatherNd.cpp
new file mode 100644
index 000000000..c04db5350
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/GatherNd.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GatherNd.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> GatherNdChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::GatherNdOptionsBuilder gather_nd_options_builder{fbb};
+  return gather_nd_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> GatherNdChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new GatherNdChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/GatherNd.h b/compiler/tflchef/core/src/Op/GatherNd.h
new file mode 100644
index 000000000..8865e7756
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/GatherNd.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_GATHER_ND_H__
+#define __OP_GATHER_ND_H__
+
+#include "OpChef.h"
+
+class GatherNdChef final : public OpChef
+{
+public:
+  explicit GatherNdChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_GATHER_ND; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_GatherNdOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct GatherNdChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_GATHER_ND_H__
diff --git a/compiler/tflchef/core/src/LexicalCast.h b/compiler/tflchef/core/src/Op/Greater.cpp
index 4aeccb482..81765aee5 100644
--- a/compiler/tflchef/core/src/LexicalCast.h
+++ b/compiler/tflchef/core/src/Op/Greater.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,16 @@
  * limitations under the License.
  */
 
-/**
- * @brief This file provides string <-> number cast helpers
- */
-#ifndef __LEXICAL_CAST_H__
-#define __LEXICAL_CAST_H__
+#include "Greater.h"
 
-#include <string>
+flatbuffers::Offset<void> GreaterChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::GreaterOptionsBuilder options_builder{fbb};
 
-/**
- * @brief Return a numeric value that corresponds to a given string
- *
- * @note This function will throw an exception on casting failure
- */
-template <typename Number> Number to_number(const std::string &s);
+  return options_builder.Finish().Union();
+}
 
-#endif // __LEXICAL_CAST_H__
+std::unique_ptr<OpChef> GreaterChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new GreaterChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Greater.h b/compiler/tflchef/core/src/Op/Greater.h
new file mode 100644
index 000000000..c54eaa6cc
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Greater.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_GREATER_H__
+#define __OP_GREATER_H__
+
+#include "OpChef.h"
+
+class GreaterChef final : public OpChef
+{
+public:
+  explicit GreaterChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_GREATER; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_GreaterOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct GreaterChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_GREATER_H__
diff --git a/compiler/tflchef/core/src/Op/GreaterEqual.cpp b/compiler/tflchef/core/src/Op/GreaterEqual.cpp
new file mode 100644
index 000000000..80045f6aa
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/GreaterEqual.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GreaterEqual.h"
+
+flatbuffers::Offset<void> GreaterEqualChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::GreaterEqualOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> GreaterEqualChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new GreaterEqualChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/GreaterEqual.h b/compiler/tflchef/core/src/Op/GreaterEqual.h
new file mode 100644
index 000000000..105bac8a7
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/GreaterEqual.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_GREATEREQUAL_H__
+#define __OP_GREATEREQUAL_H__
+
+#include "OpChef.h"
+
+class GreaterEqualChef final : public OpChef
+{
+public:
+  explicit GreaterEqualChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_GREATER_EQUAL;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_GreaterEqualOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct GreaterEqualChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_GREATEREQUAL_H__
diff --git a/compiler/tflchef/core/src/Op/If.cpp b/compiler/tflchef/core/src/Op/If.cpp
new file mode 100644
index 000000000..b0e575e2b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/If.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "If.h"
+
+flatbuffers::Offset<void> IfChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_if_options());
+
+  tflite::IfOptionsBuilder if_options_builder{fbb};
+  if_options_builder.add_then_subgraph_index(operation.if_options().then_subgraph_index());
+  if_options_builder.add_else_subgraph_index(operation.if_options().else_subgraph_index());
+
+  return if_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> IfChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new IfChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/If.h b/compiler/tflchef/core/src/Op/If.h
new file mode 100644
index 000000000..7e18c5609
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/If.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_IF_H__
+#define __OP_IF_H__
+
+#include "OpChef.h"
+
+class IfChef final : public OpChef
+{
+public:
+  explicit IfChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_IF; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_IfOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct IfChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_IF_H__
diff --git a/compiler/tflchef/core/src/Op/L2Normalize.cpp b/compiler/tflchef/core/src/Op/L2Normalize.cpp
new file mode 100644
index 000000000..62d15e56e
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/L2Normalize.cpp
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "L2Normalize.h"
+#include "Convert.h"
+
+flatbuffers::Offset<void> L2Normalize::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  tflite::L2NormOptionsBuilder l2norm_options_builder{fbb};
+  auto tflite_activation = as_tflite_activation(operation.l2norm_options().activation());
+  l2norm_options_builder.add_fused_activation_function(tflite_activation);
+  return l2norm_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> L2NormalizeChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new L2Normalize{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/L2Normalize.h b/compiler/tflchef/core/src/Op/L2Normalize.h
new file mode 100644
index 000000000..dd5f21cae
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/L2Normalize.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_L2NORMALIZE_H__
+#define __OP_L2NORMALIZE_H__
+
+#include "OpChef.h"
+
+class L2Normalize final : public OpChef
+{
+public:
+  explicit L2Normalize(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_L2_NORMALIZATION;
+  }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_L2NormOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct L2NormalizeChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_L2NORMALIZE_H__
diff --git a/compiler/tflchef/core/src/Op/L2Pool2D.cpp b/compiler/tflchef/core/src/Op/L2Pool2D.cpp
new file mode 100644
index 000000000..f22bb9642
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/L2Pool2D.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "L2Pool2D.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> L2Pool2DChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_l2pool2d_options());
+
+  auto options = operation.l2pool2d_options();
+
+  auto tflite_padding = as_tflite_padding(options.padding());
+  auto tflite_activation = as_tflite_activation(options.activation());
+
+  tflite::Pool2DOptionsBuilder options_builder{fbb};
+  options_builder.add_padding(tflite_padding);
+  options_builder.add_stride_h(options.stride_h());
+  options_builder.add_stride_w(options.stride_w());
+  options_builder.add_filter_width(options.filter_width());
+  options_builder.add_filter_height(options.filter_height());
+  options_builder.add_fused_activation_function(tflite_activation);
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> L2Pool2DChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new L2Pool2DChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/L2Pool2D.h b/compiler/tflchef/core/src/Op/L2Pool2D.h
new file mode 100644
index 000000000..6bd8bdb4d
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/L2Pool2D.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_L2_POOL_2D_H__
+#define __OP_L2_POOL_2D_H__
+
+#include "OpChef.h"
+
+class L2Pool2DChef final : public OpChef
+{
+public:
+  explicit L2Pool2DChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_L2_POOL_2D; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_Pool2DOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct L2Pool2DChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_L2_POOL_2D_H__
diff --git a/compiler/tflchef/core/src/Op/LeakyRelu.cpp b/compiler/tflchef/core/src/Op/LeakyRelu.cpp
new file mode 100644
index 000000000..247739ac0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LeakyRelu.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LeakyRelu.h"
+
+flatbuffers::Offset<void> LeakyReluChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  assert(_operation->has_leaky_relu_options());
+
+  const auto &options = _operation->leaky_relu_options();
+
+  tflite::LeakyReluOptionsBuilder options_builder{fbb};
+  options_builder.add_alpha(options.alpha());
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> LeakyReluChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LeakyReluChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/LeakyRelu.h b/compiler/tflchef/core/src/Op/LeakyRelu.h
new file mode 100644
index 000000000..5449e593b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LeakyRelu.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LEAKY_RELU_H__
+#define __OP_LEAKY_RELU_H__
+
+#include "OpChef.h"
+
+class LeakyReluChef final : public OpChef
+{
+public:
+  explicit LeakyReluChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LEAKY_RELU; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_LeakyReluOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LeakyReluChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LEAKY_RELU_H__
diff --git a/compiler/tflchef/core/src/Op/Less.cpp b/compiler/tflchef/core/src/Op/Less.cpp
new file mode 100644
index 000000000..c143d8332
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Less.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Less.h"
+
+flatbuffers::Offset<void> LessChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::LessOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> LessChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LessChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Less.h b/compiler/tflchef/core/src/Op/Less.h
new file mode 100644
index 000000000..280036c3a
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Less.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LESS_H__
+#define __OP_LESS_H__
+
+#include "OpChef.h"
+
+class LessChef final : public OpChef
+{
+public:
+  explicit LessChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LESS; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_LessOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LessChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LESS_H__
diff --git a/compiler/tflchef/core/src/Op/LessEqual.cpp b/compiler/tflchef/core/src/Op/LessEqual.cpp
new file mode 100644
index 000000000..dc383e785
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LessEqual.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LessEqual.h"
+
+flatbuffers::Offset<void> LessEqualChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::LessEqualOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> LessEqualChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LessEqualChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/LessEqual.h b/compiler/tflchef/core/src/Op/LessEqual.h
new file mode 100644
index 000000000..1315b9c53
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LessEqual.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LESSEQUAL_H__
+#define __OP_LESSEQUAL_H__
+
+#include "OpChef.h"
+
+class LessEqualChef final : public OpChef
+{
+public:
+  explicit LessEqualChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LESS_EQUAL; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_LessEqualOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LessEqualChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LESSEQUAL_H__
diff --git a/compiler/tflchef/core/src/Op/LocalResponseNormalization.cpp b/compiler/tflchef/core/src/Op/LocalResponseNormalization.cpp
new file mode 100644
index 000000000..f5430d4ca
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LocalResponseNormalization.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LocalResponseNormalization.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void>
+LocalResponseNormalizationChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_local_response_normalization_options());
+
+  auto &lrn_options = operation.local_response_normalization_options();
+
+  auto tflite_radius = lrn_options.radius();
+  auto tflite_bias = lrn_options.bias();
+  auto tflite_alpha = lrn_options.alpha();
+  auto tflite_beta = lrn_options.beta();
+
+  tflite::LocalResponseNormalizationOptionsBuilder lrn_options_builder{fbb};
+
+  lrn_options_builder.add_radius(tflite_radius);
+  lrn_options_builder.add_bias(tflite_bias);
+  lrn_options_builder.add_alpha(tflite_alpha);
+  lrn_options_builder.add_beta(tflite_beta);
+
+  return lrn_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef>
+LocalResponseNormalizationChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LocalResponseNormalizationChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/LocalResponseNormalization.h b/compiler/tflchef/core/src/Op/LocalResponseNormalization.h
new file mode 100644
index 000000000..62a2355f2
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LocalResponseNormalization.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LOCAL_RESPONSE_NORMALIZATION_H__
+#define __OP_LOCAL_RESPONSE_NORMALIZATION_H__
+
+#include "OpChef.h"
+
+class LocalResponseNormalizationChef final : public OpChef
+{
+public:
+  explicit LocalResponseNormalizationChef(const tflchef::Operation *operation)
+      : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_LocalResponseNormalizationOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LocalResponseNormalizationChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LOCAL_RESPONSE_NORMALIZATION_H__
diff --git a/compiler/tflchef/core/src/Op/Log.cpp b/compiler/tflchef/core/src/Op/Log.cpp
new file mode 100644
index 000000000..c4e65adec
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Log.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Log.h"
+
+flatbuffers::Offset<void> LogChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Log. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> LogChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LogChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Log.h b/compiler/tflchef/core/src/Op/Log.h
new file mode 100644
index 000000000..2cc8a663b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Log.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LOG_H__
+#define __OP_LOG_H__
+
+#include "OpChef.h"
+
+class LogChef final : public OpChef
+{
+public:
+  explicit LogChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LOG; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LogChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LOG_H__
diff --git a/compiler/tflchef/core/src/Op/LogSoftmax.cpp b/compiler/tflchef/core/src/Op/LogSoftmax.cpp
new file mode 100644
index 000000000..eb2f13243
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LogSoftmax.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LogSoftmax.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> LogSoftmaxChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::LogSoftmaxOptionsBuilder soft_options_builder{fbb};
+
+  return soft_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> LogSoftmaxChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LogSoftmaxChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/LogSoftmax.h b/compiler/tflchef/core/src/Op/LogSoftmax.h
new file mode 100644
index 000000000..3ce08b739
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LogSoftmax.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LOG_SOFTMAX_H__
+#define __OP_LOG_SOFTMAX_H__
+
+#include "OpChef.h"
+
+class LogSoftmaxChef final : public OpChef
+{
+public:
+  explicit LogSoftmaxChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LOG_SOFTMAX; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_LogSoftmaxOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LogSoftmaxChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LOG_SOFTMAX_H__
diff --git a/compiler/tflchef/core/src/Op/LogicalAnd.cpp b/compiler/tflchef/core/src/Op/LogicalAnd.cpp
new file mode 100644
index 000000000..64a6113db
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LogicalAnd.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LogicalAnd.h"
+
+flatbuffers::Offset<void> LogicalAndChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::LogicalAndOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> LogicalAndChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LogicalAndChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/LogicalAnd.h b/compiler/tflchef/core/src/Op/LogicalAnd.h
new file mode 100644
index 000000000..1f272274f
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/LogicalAnd.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LOGICALAND_H__
+#define __OP_LOGICALAND_H__
+
+#include "OpChef.h"
+
+class LogicalAndChef final : public OpChef
+{
+public:
+  explicit LogicalAndChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LOGICAL_AND; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_LogicalAndOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LogicalAndChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LOGICALAND_H__
diff --git a/compiler/tflchef/core/src/Op/Logistic.cpp b/compiler/tflchef/core/src/Op/Logistic.cpp
new file mode 100644
index 000000000..4a5808235
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Logistic.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Logistic.h"
+
+flatbuffers::Offset<void> LogisticChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Logistic. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> LogisticChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new LogisticChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Logistic.h b/compiler/tflchef/core/src/Op/Logistic.h
new file mode 100644
index 000000000..c158af34d
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Logistic.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_LOGISTIC_H__
+#define __OP_LOGISTIC_H__
+
+#include "OpChef.h"
+
+class LogisticChef final : public OpChef
+{
+public:
+  explicit LogisticChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_LOGISTIC; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct LogisticChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_LOGISTIC_H__
diff --git a/compiler/tflchef/core/src/Op/MatrixDiag.cpp b/compiler/tflchef/core/src/Op/MatrixDiag.cpp
new file mode 100644
index 000000000..de505c056
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MatrixDiag.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatrixDiag.h"
+
+flatbuffers::Offset<void> MatrixDiagChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::MatrixDiagOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> MatrixDiagChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MatrixDiagChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/MatrixDiag.h b/compiler/tflchef/core/src/Op/MatrixDiag.h
new file mode 100644
index 000000000..cbadf6b99
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MatrixDiag.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MATRIX_DIAG_H__
+#define __OP_MATRIX_DIAG_H__
+
+#include "OpChef.h"
+
+class MatrixDiagChef final : public OpChef
+{
+public:
+  explicit MatrixDiagChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_MATRIX_DIAG; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_MatrixDiagOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MatrixDiagChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MATRIX_DIAG_H__
diff --git a/compiler/tflchef/core/src/Op/MatrixSetDiag.cpp b/compiler/tflchef/core/src/Op/MatrixSetDiag.cpp
new file mode 100644
index 000000000..0a4ee71c9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MatrixSetDiag.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatrixSetDiag.h"
+
+flatbuffers::Offset<void> MatrixSetDiagChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::MatrixSetDiagOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> MatrixSetDiagChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MatrixSetDiagChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/MatrixSetDiag.h b/compiler/tflchef/core/src/Op/MatrixSetDiag.h
new file mode 100644
index 000000000..8114d32a8
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MatrixSetDiag.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MATRIX_SET_DIAG_H__
+#define __OP_MATRIX_SET_DIAG_H__
+
+#include "OpChef.h"
+
+class MatrixSetDiagChef final : public OpChef
+{
+public:
+  explicit MatrixSetDiagChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_MATRIX_SET_DIAG;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_MatrixSetDiagOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MatrixSetDiagChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MATRIX_SET_DIAG_H__
diff --git a/compiler/tflchef/core/src/Op/Maximum.cpp b/compiler/tflchef/core/src/Op/Maximum.cpp
new file mode 100644
index 000000000..8f415e2e4
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Maximum.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Maximum.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> MaximumChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::MaximumMinimumOptionsBuilder maximum_options_builder{fbb};
+  return maximum_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> MaximumChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MaximumChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Maximum.h b/compiler/tflchef/core/src/Op/Maximum.h
new file mode 100644
index 000000000..53e95240c
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Maximum.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MAXIMUM_H__
+#define __OP_MAXIMUM_H__
+
+#include "OpChef.h"
+
+class MaximumChef final : public OpChef
+{
+public:
+  explicit MaximumChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_MAXIMUM; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_MaximumMinimumOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MaximumChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MAXIMUM_H__
diff --git a/compiler/tflchef/core/src/Op/Minimum.cpp b/compiler/tflchef/core/src/Op/Minimum.cpp
new file mode 100644
index 000000000..cc0c91901
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Minimum.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Minimum.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> MinimumChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::MaximumMinimumOptionsBuilder minimum_options_builder{fbb};
+  return minimum_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> MinimumChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MinimumChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Minimum.h b/compiler/tflchef/core/src/Op/Minimum.h
new file mode 100644
index 000000000..3990e1eca
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Minimum.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MINIMUM_H__
+#define __OP_MINIMUM_H__
+
+#include "OpChef.h"
+
+class MinimumChef final : public OpChef
+{
+public:
+  explicit MinimumChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_MINIMUM; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_MaximumMinimumOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MinimumChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MINIMUM_H__
diff --git a/compiler/tflchef/core/src/Op/MirrorPad.cpp b/compiler/tflchef/core/src/Op/MirrorPad.cpp
new file mode 100644
index 000000000..2d68b6986
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MirrorPad.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MirrorPad.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> MirrorPadChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_mirrorpad_options());
+
+  auto options = operation.mirrorpad_options();
+
+  auto tflite_mode = as_tflite_mirrorpadmode(options.mode());
+
+  tflite::MirrorPadOptionsBuilder options_builder{fbb};
+  options_builder.add_mode(tflite_mode);
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> MirrorPadChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new MirrorPadChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/MirrorPad.h b/compiler/tflchef/core/src/Op/MirrorPad.h
new file mode 100644
index 000000000..49461df35
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/MirrorPad.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_MIRRORPAD_H__
+#define __OP_MIRRORPAD_H__
+
+#include "OpChef.h"
+
+class MirrorPadChef final : public OpChef
+{
+public:
+  explicit MirrorPadChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_MIRROR_PAD; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_MirrorPadOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct MirrorPadChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_MIRRORPAD_H__
diff --git a/compiler/tflchef/core/src/Op/Neg.cpp b/compiler/tflchef/core/src/Op/Neg.cpp
new file mode 100644
index 000000000..0e9fb9321
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Neg.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Neg.h"
+#include "Convert.h"
+
+flatbuffers::Offset<void> NegChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::NegOptionsBuilder neg_options_builder{fbb};
+
+  return neg_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> NegChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new NegChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Neg.h b/compiler/tflchef/core/src/Op/Neg.h
new file mode 100644
index 000000000..f7a2692c9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Neg.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_NEG_H__
+#define __OP_NEG_H__
+
+#include "OpChef.h"
+
+class NegChef final : public OpChef
+{
+public:
+  explicit NegChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_NEG; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NegOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct NegChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_NEG_H__
diff --git a/compiler/tflchef/core/src/Op/NotEqual.cpp b/compiler/tflchef/core/src/Op/NotEqual.cpp
new file mode 100644
index 000000000..a408266f9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/NotEqual.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "NotEqual.h"
+
+flatbuffers::Offset<void> NotEqualChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::NotEqualOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> NotEqualChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new NotEqualChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/NotEqual.h b/compiler/tflchef/core/src/Op/NotEqual.h
new file mode 100644
index 000000000..3fd254773
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/NotEqual.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_NOT_EQUAL_H__
+#define __OP_NOT_EQUAL_H__
+
+#include "OpChef.h"
+
+class NotEqualChef final : public OpChef
+{
+public:
+  explicit NotEqualChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_NOT_EQUAL; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_NotEqualOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct NotEqualChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_NOT_EQUAL_H__
diff --git a/compiler/tflchef/core/src/Op/OneHot.cpp b/compiler/tflchef/core/src/Op/OneHot.cpp
new file mode 100644
index 000000000..421e50c9f
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/OneHot.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "OneHot.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> OneHotChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_onehot_options());
+
+  auto options = operation.onehot_options();
+
+  tflite::OneHotOptionsBuilder options_builder{fbb};
+
+  options_builder.add_axis(options.axis());
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> OneHotChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new OneHotChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/OneHot.h b/compiler/tflchef/core/src/Op/OneHot.h
new file mode 100644
index 000000000..b29cb7978
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/OneHot.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ONEHOT_H__
+#define __OP_ONEHOT_H__
+
+#include "OpChef.h"
+
+class OneHotChef final : public OpChef
+{
+public:
+  explicit OneHotChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ONE_HOT; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_OneHotOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct OneHotChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ONEHOT_H__
diff --git a/compiler/tflchef/core/src/Op/PRelu.cpp b/compiler/tflchef/core/src/Op/PRelu.cpp
new file mode 100644
index 000000000..30e8b8ef4
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/PRelu.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "PRelu.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> PReluChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No option for PRelu
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> PReluChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new PReluChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/PRelu.h b/compiler/tflchef/core/src/Op/PRelu.h
new file mode 100644
index 000000000..4a5a935ed
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/PRelu.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_PRELU_H__
+#define __OP_PRELU_H__
+
+#include "OpChef.h"
+
+class PReluChef final : public OpChef
+{
+public:
+  explicit PReluChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_PRELU; }
+
+  // no builtin options for PRelu
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct PReluChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_PRELU_H__
diff --git a/compiler/tflchef/core/src/Op/Pow.cpp b/compiler/tflchef/core/src/Op/Pow.cpp
new file mode 100644
index 000000000..25e180237
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Pow.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Pow.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> PowChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::PowOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> PowChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new PowChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Pow.h b/compiler/tflchef/core/src/Op/Pow.h
new file mode 100644
index 000000000..f2d809e92
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Pow.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_POW_H__
+#define __OP_POW_H__
+
+#include "OpChef.h"
+
+class PowChef final : public OpChef
+{
+public:
+  explicit PowChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_POW; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_PowOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct PowChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_POW_H__
diff --git a/compiler/tflchef/core/src/Op/Range.cpp b/compiler/tflchef/core/src/Op/Range.cpp
new file mode 100644
index 000000000..189c46526
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Range.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Range.h"
+
+#include <cassert>
+#include <vector>
+
+flatbuffers::Offset<void> RangeChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::RangeOptionsBuilder options_builder{fbb};
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> RangeChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new RangeChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Range.h b/compiler/tflchef/core/src/Op/Range.h
new file mode 100644
index 000000000..f294d15a7
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Range.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_RANGE_H__
+#define __OP_RANGE_H__
+
+#include "OpChef.h"
+
+class RangeChef final : public OpChef
+{
+public:
+  explicit RangeChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_RANGE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_RangeOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct RangeChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_RANGE_H__
diff --git a/compiler/tflchef/core/src/Op/Rank.cpp b/compiler/tflchef/core/src/Op/Rank.cpp
new file mode 100644
index 000000000..4eb2aa776
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Rank.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Rank.h"
+
+flatbuffers::Offset<void> RankChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::RankOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> RankChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new RankChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Rank.h b/compiler/tflchef/core/src/Op/Rank.h
new file mode 100644
index 000000000..0bce38095
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Rank.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_RANK_H__
+#define __OP_RANK_H__
+
+#include "OpChef.h"
+
+class RankChef final : public OpChef
+{
+public:
+  explicit RankChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_RANK; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_RankOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct RankChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_RANK_H__
diff --git a/compiler/tflchef/core/src/Op/ReLUN1To1.cpp b/compiler/tflchef/core/src/Op/ReLUN1To1.cpp
new file mode 100644
index 000000000..d57e82341
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReLUN1To1.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReLUN1To1.h"
+
+flatbuffers::Offset<void> ReLUN1To1Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> ReLUN1To1ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReLUN1To1Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReLUN1To1.h b/compiler/tflchef/core/src/Op/ReLUN1To1.h
new file mode 100644
index 000000000..e034c7999
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReLUN1To1.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_RELU_N1_TO_1_H__
+#define __OP_RELU_N1_TO_1_H__
+
+#include "OpChef.h"
+
+class ReLUN1To1Chef final : public OpChef
+{
+public:
+  explicit ReLUN1To1Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_RELU_N1_TO_1; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReLUN1To1ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_RELU_N1_TO_1_H__
diff --git a/compiler/tflchef/core/src/Op/ReduceAny.cpp b/compiler/tflchef/core/src/Op/ReduceAny.cpp
new file mode 100644
index 000000000..c94c8a3a4
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceAny.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceAny.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ReduceAnyChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_reduce_any_options());
+
+  auto keep_dims = operation.reduce_any_options().keep_dims();
+
+  tflite::ReducerOptionsBuilder reducer_options_builder{fbb};
+  reducer_options_builder.add_keep_dims(keep_dims);
+
+  return reducer_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ReduceAnyChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReduceAnyChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReduceAny.h b/compiler/tflchef/core/src/Op/ReduceAny.h
new file mode 100644
index 000000000..cf6531732
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceAny.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REDUCE_ANY_H__
+#define __OP_REDUCE_ANY_H__
+
+#include "OpChef.h"
+
+class ReduceAnyChef final : public OpChef
+{
+public:
+  explicit ReduceAnyChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_REDUCE_ANY; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ReducerOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReduceAnyChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REDUCE_ANY_H__
diff --git a/compiler/tflchef/core/src/Op/ReduceMax.cpp b/compiler/tflchef/core/src/Op/ReduceMax.cpp
new file mode 100644
index 000000000..31543cdc0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceMax.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceMax.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ReduceMaxChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_reduce_max_options());
+
+  auto keep_dims = operation.reduce_max_options().keep_dims();
+
+  tflite::ReducerOptionsBuilder reduce_max_options_builder{fbb};
+  reduce_max_options_builder.add_keep_dims(keep_dims);
+
+  return reduce_max_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ReduceMaxChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReduceMaxChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReduceMax.h b/compiler/tflchef/core/src/Op/ReduceMax.h
new file mode 100644
index 000000000..854c5b87d
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceMax.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REDUCEMAX_H__
+#define __OP_REDUCEMAX_H__
+
+#include "OpChef.h"
+
+class ReduceMaxChef final : public OpChef
+{
+public:
+  explicit ReduceMaxChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_REDUCE_MAX; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ReducerOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReduceMaxChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REDUCEMAX_H__
diff --git a/compiler/tflchef/core/src/Op/ReduceMin.cpp b/compiler/tflchef/core/src/Op/ReduceMin.cpp
new file mode 100644
index 000000000..e194a1837
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceMin.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceMin.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ReduceMinChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_reduce_min_options());
+
+  auto keep_dims = operation.reduce_min_options().keep_dims();
+
+  tflite::ReducerOptionsBuilder reduce_min_options_builder{fbb};
+  reduce_min_options_builder.add_keep_dims(keep_dims);
+
+  return reduce_min_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ReduceMinChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReduceMinChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReduceMin.h b/compiler/tflchef/core/src/Op/ReduceMin.h
new file mode 100644
index 000000000..f29d273b9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceMin.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REDUCEMIN_H__
+#define __OP_REDUCEMIN_H__
+
+#include "OpChef.h"
+
+class ReduceMinChef final : public OpChef
+{
+public:
+  explicit ReduceMinChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_REDUCE_MIN; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ReducerOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReduceMinChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REDUCEMIN_H__
diff --git a/compiler/tflchef/core/src/Op/ReduceProd.cpp b/compiler/tflchef/core/src/Op/ReduceProd.cpp
new file mode 100644
index 000000000..c89aca27e
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceProd.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceProd.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ReduceProdChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_reduce_prod_options());
+
+  auto keep_dims = operation.reduce_prod_options().keep_dims();
+
+  tflite::ReducerOptionsBuilder reducer_options_builder{fbb};
+  reducer_options_builder.add_keep_dims(keep_dims);
+
+  return reducer_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ReduceProdChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReduceProdChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReduceProd.h b/compiler/tflchef/core/src/Op/ReduceProd.h
new file mode 100644
index 000000000..d5a11fdbc
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReduceProd.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REDUCE_PROD_H__
+#define __OP_REDUCE_PROD_H__
+
+#include "OpChef.h"
+
+class ReduceProdChef final : public OpChef
+{
+public:
+  explicit ReduceProdChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_REDUCE_PROD; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ReducerOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReduceProdChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REDUCE_PROD_H__
diff --git a/compiler/tflchef/core/src/Op/Reshape.cpp b/compiler/tflchef/core/src/Op/Reshape.cpp
index 99555e898..01e521913 100644
--- a/compiler/tflchef/core/src/Op/Reshape.cpp
+++ b/compiler/tflchef/core/src/Op/Reshape.cpp
@@ -41,7 +41,8 @@ flatbuffers::Offset<void> ReshapeChef::value(flatbuffers::FlatBufferBuilder &fbb
 {
   auto &operation = (*_operation);
 
-  assert(operation.has_reshape_options());
+  if (!operation.has_reshape_options())
+    return 0;
 
   auto options = operation.reshape_options();
   auto shapes = vector_new_shape(options);
diff --git a/compiler/tflchef/core/src/Op/ResizeBilinear.cpp b/compiler/tflchef/core/src/Op/ResizeBilinear.cpp
new file mode 100644
index 000000000..3d9299ce0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ResizeBilinear.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ResizeBilinear.h"
+#include "Convert.h"
+
+#include <cassert>
+#include <vector>
+
+flatbuffers::Offset<void> ResizeBilinearChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_resize_bilinear_options());
+
+  auto options = operation.resize_bilinear_options();
+
+  tflite::ResizeBilinearOptionsBuilder options_builder{fbb};
+
+  options_builder.add_align_corners(options.align_corners());
+  options_builder.add_half_pixel_centers(options.half_pixel_centers());
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ResizeBilinearChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ResizeBilinearChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ResizeBilinear.h b/compiler/tflchef/core/src/Op/ResizeBilinear.h
new file mode 100644
index 000000000..9bd618538
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ResizeBilinear.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_RESIZE_BILINEAR_H__
+#define __OP_RESIZE_BILINEAR_H__
+
+#include "OpChef.h"
+
+class ResizeBilinearChef final : public OpChef
+{
+public:
+  explicit ResizeBilinearChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_RESIZE_BILINEAR;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ResizeBilinearOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ResizeBilinearChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_RESIZE_BILINEAR_H__
diff --git a/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.cpp b/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.cpp
new file mode 100644
index 000000000..1f930404f
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ResizeNearestNeighbor.h"
+#include "Convert.h"
+
+#include <cassert>
+#include <vector>
+
+flatbuffers::Offset<void>
+ResizeNearestNeighborChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_resize_nearest_neighbor_options());
+
+  auto options = operation.resize_nearest_neighbor_options();
+
+  tflite::ResizeNearestNeighborOptionsBuilder options_builder{fbb};
+
+  options_builder.add_align_corners(options.align_corners());
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef>
+ResizeNearestNeighborChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ResizeNearestNeighborChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.h b/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.h
new file mode 100644
index 000000000..e6ee832a8
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ResizeNearestNeighbor.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_RESIZE_NEAREST_NEIGHBOR_H__
+#define __OP_RESIZE_NEAREST_NEIGHBOR_H__
+
+#include "OpChef.h"
+
+class ResizeNearestNeighborChef final : public OpChef
+{
+public:
+  explicit ResizeNearestNeighborChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_RESIZE_NEAREST_NEIGHBOR;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ResizeNearestNeighborOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ResizeNearestNeighborChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_RESIZE_NEAREST_NEIGHBOR_H__
diff --git a/compiler/tflchef/core/src/Op/ReverseSequence.cpp b/compiler/tflchef/core/src/Op/ReverseSequence.cpp
new file mode 100644
index 000000000..93541172b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReverseSequence.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReverseSequence.h"
+
+flatbuffers::Offset<void> ReverseSequenceChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_reverse_sequence_options());
+
+  auto options = operation.reverse_sequence_options();
+
+  auto tflite_seq_dim = options.seq_dim();
+  auto tflite_batch_dim = options.batch_dim();
+
+  tflite::ReverseSequenceOptionsBuilder options_builder{fbb};
+
+  options_builder.add_seq_dim(tflite_seq_dim);
+  options_builder.add_batch_dim(tflite_batch_dim);
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef>
+ReverseSequenceChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReverseSequenceChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReverseSequence.h b/compiler/tflchef/core/src/Op/ReverseSequence.h
new file mode 100644
index 000000000..329505cf0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReverseSequence.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REVERSE_SEQUENCE_H__
+#define __OP_REVERSE_SEQUENCE_H__
+
+#include "OpChef.h"
+
+class ReverseSequenceChef final : public OpChef
+{
+public:
+  explicit ReverseSequenceChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_REVERSE_SEQUENCE;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ReverseSequenceOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReverseSequenceChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REVERSE_SEQUENCE_H__
diff --git a/compiler/tflchef/core/src/Op/ReverseV2.cpp b/compiler/tflchef/core/src/Op/ReverseV2.cpp
new file mode 100644
index 000000000..58ace1dd1
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReverseV2.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReverseV2.h"
+
+flatbuffers::Offset<void> ReverseV2Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::ReverseV2OptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ReverseV2ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ReverseV2Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ReverseV2.h b/compiler/tflchef/core/src/Op/ReverseV2.h
new file mode 100644
index 000000000..a48a2d96a
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ReverseV2.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_REVERSEV2_H__
+#define __OP_REVERSEV2_H__
+
+#include "OpChef.h"
+
+class ReverseV2Chef final : public OpChef
+{
+public:
+  explicit ReverseV2Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_REVERSE_V2; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ReverseV2Options;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ReverseV2ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_REVERSEV2_H__
diff --git a/compiler/tflchef/core/src/Op/Round.cpp b/compiler/tflchef/core/src/Op/Round.cpp
new file mode 100644
index 000000000..e16c86518
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Round.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Round.h"
+
+flatbuffers::Offset<void> RoundChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Round. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> RoundChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new RoundChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Round.h b/compiler/tflchef/core/src/Op/Round.h
new file mode 100644
index 000000000..7f0fbe370
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Round.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ROUND_H__
+#define __OP_ROUND_H__
+
+#include "OpChef.h"
+
+class RoundChef final : public OpChef
+{
+public:
+  explicit RoundChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ROUND; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct RoundChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ROUND_H__
diff --git a/compiler/tflchef/core/src/Op/ScatterNd.cpp b/compiler/tflchef/core/src/Op/ScatterNd.cpp
new file mode 100644
index 000000000..7114dda6e
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ScatterNd.cpp
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ScatterNd.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> ScatterNdChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::ScatterNdOptionsBuilder scatter_nd_options_builder{fbb};
+
+  return scatter_nd_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ScatterNdChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ScatterNdChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ScatterNd.h b/compiler/tflchef/core/src/Op/ScatterNd.h
new file mode 100644
index 000000000..2c89cf6a0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ScatterNd.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SCATTER_ND_H__
+#define __OP_SCATTER_ND_H__
+
+#include "OpChef.h"
+
+class ScatterNdChef final : public OpChef
+{
+public:
+  explicit ScatterNdChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SCATTER_ND; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ScatterNdOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ScatterNdChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SCATTER_ND_H__
diff --git a/compiler/tflchef/core/src/Op/SegmentSum.cpp b/compiler/tflchef/core/src/Op/SegmentSum.cpp
new file mode 100644
index 000000000..934bcb0ec
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SegmentSum.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SegmentSum.h"
+
+flatbuffers::Offset<void> SegmentSumChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SegmentSumOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SegmentSumChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SegmentSumChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SegmentSum.h b/compiler/tflchef/core/src/Op/SegmentSum.h
new file mode 100644
index 000000000..c0ebfba52
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SegmentSum.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SEGMENT_SUM_H__
+#define __OP_SEGMENT_SUM_H__
+
+#include "OpChef.h"
+
+class SegmentSumChef final : public OpChef
+{
+public:
+  explicit SegmentSumChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SEGMENT_SUM; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SegmentSumOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SegmentSumChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SEGMENT_SUM_H__
diff --git a/compiler/tflchef/core/src/Op/Select.cpp b/compiler/tflchef/core/src/Op/Select.cpp
new file mode 100644
index 000000000..31be736c9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Select.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Select.h"
+
+flatbuffers::Offset<void> SelectChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SelectOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SelectChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SelectChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Select.h b/compiler/tflchef/core/src/Op/Select.h
new file mode 100644
index 000000000..91ace16e1
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Select.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SELECT_H__
+#define __OP_SELECT_H__
+
+#include "OpChef.h"
+
+class SelectChef final : public OpChef
+{
+public:
+  explicit SelectChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SELECT; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SelectOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SelectChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SELECT_H__
diff --git a/compiler/tflchef/core/src/Op/SelectV2.cpp b/compiler/tflchef/core/src/Op/SelectV2.cpp
new file mode 100644
index 000000000..f6c0bfc49
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SelectV2.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SelectV2.h"
+
+flatbuffers::Offset<void> SelectV2Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SelectV2OptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SelectV2ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SelectV2Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SelectV2.h b/compiler/tflchef/core/src/Op/SelectV2.h
new file mode 100644
index 000000000..36d74c344
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SelectV2.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SELECT_V2_H__
+#define __OP_SELECT_V2_H__
+
+#include "OpChef.h"
+
+class SelectV2Chef final : public OpChef
+{
+public:
+  explicit SelectV2Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SELECT_V2; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SelectV2Options;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SelectV2ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SELECT_V2_H__
diff --git a/compiler/tflchef/core/src/Op/Sin.cpp b/compiler/tflchef/core/src/Op/Sin.cpp
new file mode 100644
index 000000000..1752ce7a1
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Sin.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Sin.h"
+
+flatbuffers::Offset<void> SinChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  // No tflite option for Sin. Use void.
+  return flatbuffers::Offset<void>();
+}
+
+std::unique_ptr<OpChef> SinChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SinChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Sin.h b/compiler/tflchef/core/src/Op/Sin.h
new file mode 100644
index 000000000..121b73b68
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Sin.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SIN_H__
+#define __OP_SIN_H__
+
+#include "OpChef.h"
+
+class SinChef final : public OpChef
+{
+public:
+  explicit SinChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SIN; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_NONE; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SinChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SIN_H__
diff --git a/compiler/tflchef/core/src/Op/Slice.cpp b/compiler/tflchef/core/src/Op/Slice.cpp
new file mode 100644
index 000000000..27ae80a8a
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Slice.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Slice.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SliceChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SliceOptionsBuilder slice_options_builder{fbb};
+  return slice_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SliceChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SliceChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Slice.h b/compiler/tflchef/core/src/Op/Slice.h
new file mode 100644
index 000000000..06fd6347b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Slice.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SLICE_H__
+#define __OP_SLICE_H__
+
+#include "OpChef.h"
+
+class SliceChef final : public OpChef
+{
+public:
+  explicit SliceChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SLICE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SliceOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SliceChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SLICE_H__
diff --git a/compiler/tflchef/core/src/Op/SpaceToBatchND.cpp b/compiler/tflchef/core/src/Op/SpaceToBatchND.cpp
new file mode 100644
index 000000000..74e052826
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SpaceToBatchND.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SpaceToBatchND.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SpaceToBatchNDChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SpaceToBatchNDOptionsBuilder space_to_batch_nd_options_builder{fbb};
+
+  return space_to_batch_nd_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SpaceToBatchNDChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SpaceToBatchNDChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SpaceToBatchND.h b/compiler/tflchef/core/src/Op/SpaceToBatchND.h
new file mode 100644
index 000000000..e263bdc61
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SpaceToBatchND.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SPACETOBATCHND_H__
+#define __OP_SPACETOBATCHND_H__
+
+#include "OpChef.h"
+
+class SpaceToBatchNDChef final : public OpChef
+{
+public:
+  explicit SpaceToBatchNDChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_SPACE_TO_BATCH_ND;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SpaceToBatchNDOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SpaceToBatchNDChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SPACETOBATCHND_H__
diff --git a/compiler/tflchef/core/src/Op/SpaceToDepth.cpp b/compiler/tflchef/core/src/Op/SpaceToDepth.cpp
new file mode 100644
index 000000000..98eed8c26
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SpaceToDepth.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SpaceToDepth.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SpaceToDepthChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_space_to_depth_options());
+
+  auto tflite_block_size = operation.space_to_depth_options().block_size();
+
+  tflite::SpaceToDepthOptionsBuilder std_options_builder{fbb};
+  std_options_builder.add_block_size(tflite_block_size);
+
+  return std_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SpaceToDepthChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SpaceToDepthChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SpaceToDepth.h b/compiler/tflchef/core/src/Op/SpaceToDepth.h
new file mode 100644
index 000000000..db852feac
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SpaceToDepth.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SPACETODEPTH_H__
+#define __OP_SPACETODEPTH_H__
+
+#include "OpChef.h"
+
+class SpaceToDepthChef final : public OpChef
+{
+public:
+  explicit SpaceToDepthChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_SPACE_TO_DEPTH;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SpaceToDepthOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SpaceToDepthChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SPACETODEPTH_H__
diff --git a/compiler/tflchef/core/src/Op/SparseToDense.cpp b/compiler/tflchef/core/src/Op/SparseToDense.cpp
new file mode 100644
index 000000000..f1f8a7150
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SparseToDense.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SparseToDense.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SparseToDenseChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_sparse_to_dense_options());
+
+  auto tflite_validate_indices = operation.sparse_to_dense_options().validate_indices();
+
+  tflite::SparseToDenseOptionsBuilder sparse_to_dense_options_builder(fbb);
+  sparse_to_dense_options_builder.add_validate_indices(tflite_validate_indices);
+
+  return sparse_to_dense_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SparseToDenseChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SparseToDenseChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SparseToDense.h b/compiler/tflchef/core/src/Op/SparseToDense.h
new file mode 100644
index 000000000..02cbd6a6d
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SparseToDense.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SPARSETODENSE_H__
+#define __OP_SPARSETODENSE_H__
+
+#include "OpChef.h"
+
+class SparseToDenseChef final : public OpChef
+{
+public:
+  explicit SparseToDenseChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_SPARSE_TO_DENSE;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SparseToDenseOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SparseToDenseChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SPARSETODENSE_H__
diff --git a/compiler/tflchef/core/src/Op/Split.cpp b/compiler/tflchef/core/src/Op/Split.cpp
new file mode 100644
index 000000000..f4704e537
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Split.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Split.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SplitChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_split_options());
+
+  auto num_splits = operation.split_options().num_splits();
+
+  tflite::SplitOptionsBuilder split_options_builder{fbb};
+  split_options_builder.add_num_splits(num_splits);
+
+  return split_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SplitChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SplitChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Split.h b/compiler/tflchef/core/src/Op/Split.h
new file mode 100644
index 000000000..db6158069
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Split.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SPLIT_H__
+#define __OP_SPLIT_H__
+
+#include "OpChef.h"
+
+class SplitChef final : public OpChef
+{
+public:
+  explicit SplitChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SPLIT; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SplitOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SplitChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SPLIT_H__
diff --git a/compiler/tflchef/core/src/Op/SplitV.cpp b/compiler/tflchef/core/src/Op/SplitV.cpp
new file mode 100644
index 000000000..fa93db6ba
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SplitV.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SplitV.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SplitVChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_split_v_options());
+
+  auto num_splits = operation.split_v_options().num_splits();
+
+  tflite::SplitVOptionsBuilder split_v_options_builder{fbb};
+  split_v_options_builder.add_num_splits(num_splits);
+
+  return split_v_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SplitVChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SplitVChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SplitV.h b/compiler/tflchef/core/src/Op/SplitV.h
new file mode 100644
index 000000000..c37736e31
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SplitV.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SPLIT_V_H__
+#define __OP_SPLIT_V_H__
+
+#include "OpChef.h"
+
+class SplitVChef final : public OpChef
+{
+public:
+  explicit SplitVChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SPLIT_V; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SplitVOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SplitVChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SPLIT_V_H__
diff --git a/compiler/tflchef/core/src/Op/Square.cpp b/compiler/tflchef/core/src/Op/Square.cpp
new file mode 100644
index 000000000..fd3538072
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Square.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Square.h"
+
+flatbuffers::Offset<void> SquareChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SquareOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SquareChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SquareChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Square.h b/compiler/tflchef/core/src/Op/Square.h
new file mode 100644
index 000000000..5b76e6302
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Square.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SQUARE_H__
+#define __OP_SQUARE_H__
+
+#include "OpChef.h"
+
+class SquareChef final : public OpChef
+{
+public:
+  explicit SquareChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SQUARE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SquareOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SquareChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SQUARE_H__
diff --git a/compiler/tflchef/core/src/Op/SquaredDifference.cpp b/compiler/tflchef/core/src/Op/SquaredDifference.cpp
new file mode 100644
index 000000000..757c148a9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SquaredDifference.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SquaredDifference.h"
+
+flatbuffers::Offset<void> SquaredDifferenceChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::SquaredDifferenceOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef>
+SquaredDifferenceChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SquaredDifferenceChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/SquaredDifference.h b/compiler/tflchef/core/src/Op/SquaredDifference.h
new file mode 100644
index 000000000..f919975f9
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/SquaredDifference.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SQUAREDDIFFERENCE_H__
+#define __OP_SQUAREDDIFFERENCE_H__
+
+#include "OpChef.h"
+
+class SquaredDifferenceChef final : public OpChef
+{
+public:
+  explicit SquaredDifferenceChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_SQUARED_DIFFERENCE;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_SquaredDifferenceOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SquaredDifferenceChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SQUAREDDIFFERENCE_H__
diff --git a/compiler/tflchef/core/src/Op/Squeeze.cpp b/compiler/tflchef/core/src/Op/Squeeze.cpp
new file mode 100644
index 000000000..8d6ef42d6
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Squeeze.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Squeeze.h"
+#include "Convert.h"
+
+#include <cassert>
+#include <vector>
+
+flatbuffers::Offset<void> SqueezeChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_squeeze_options());
+
+  const auto &options = operation.squeeze_options();
+  // Note: 'CreateVector' should be placed before 'CreateOptions'
+  //       Read flatbuffers.h 'void NotNested()' for more information
+  auto fb_squeeze_dims =
+      fbb.CreateVector(options.squeeze_dim().data(), options.squeeze_dim().size());
+
+  return tflite::CreateSqueezeOptions(fbb, fb_squeeze_dims).Union();
+}
+
+std::unique_ptr<OpChef> SqueezeChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SqueezeChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Squeeze.h b/compiler/tflchef/core/src/Op/Squeeze.h
new file mode 100644
index 000000000..2787231f2
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Squeeze.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SQUEEZE_H__
+#define __OP_SQUEEZE_H__
+
+#include "OpChef.h"
+
+class SqueezeChef final : public OpChef
+{
+public:
+  explicit SqueezeChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SQUEEZE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_SqueezeOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SqueezeChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SQUEEZE_H__
diff --git a/compiler/tflchef/core/src/Op/StridedSlice.cpp b/compiler/tflchef/core/src/Op/StridedSlice.cpp
new file mode 100644
index 000000000..587a95c66
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/StridedSlice.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "StridedSlice.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> StridedSliceChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_strided_slice_options());
+
+  tflite::StridedSliceOptionsBuilder strided_slice_options_builder{fbb};
+  strided_slice_options_builder.add_begin_mask(operation.strided_slice_options().begin_mask());
+  strided_slice_options_builder.add_end_mask(operation.strided_slice_options().end_mask());
+  strided_slice_options_builder.add_ellipsis_mask(
+      operation.strided_slice_options().ellipsis_mask());
+  strided_slice_options_builder.add_new_axis_mask(
+      operation.strided_slice_options().new_axis_mask());
+  strided_slice_options_builder.add_shrink_axis_mask(
+      operation.strided_slice_options().shrink_axis_mask());
+
+  return strided_slice_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> StridedSliceChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new StridedSliceChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/StridedSlice.h b/compiler/tflchef/core/src/Op/StridedSlice.h
new file mode 100644
index 000000000..49da44f12
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/StridedSlice.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_STRIDEDSLICE_H__
+#define __OP_STRIDEDSLICE_H__
+
+#include "OpChef.h"
+
+class StridedSliceChef final : public OpChef
+{
+public:
+  explicit StridedSliceChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_STRIDED_SLICE;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_StridedSliceOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct StridedSliceChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_STRIDEDSLICE_H__
diff --git a/compiler/tflchef/core/src/Op/Sum.cpp b/compiler/tflchef/core/src/Op/Sum.cpp
new file mode 100644
index 000000000..6b79d3ec5
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Sum.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Sum.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> SumChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_sum_options());
+
+  auto keep_dims = operation.sum_options().keep_dims();
+
+  tflite::ReducerOptionsBuilder sum_options_builder{fbb};
+  sum_options_builder.add_keep_dims(keep_dims);
+
+  return sum_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> SumChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new SumChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Sum.h b/compiler/tflchef/core/src/Op/Sum.h
new file mode 100644
index 000000000..d3cc8c173
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Sum.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_SUM_H__
+#define __OP_SUM_H__
+
+#include "OpChef.h"
+
+class SumChef final : public OpChef
+{
+public:
+  explicit SumChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_SUM; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_ReducerOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct SumChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_SUM_H__
diff --git a/compiler/tflchef/core/src/Op/Tile.cpp b/compiler/tflchef/core/src/Op/Tile.cpp
new file mode 100644
index 000000000..18710b4b0
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Tile.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Tile.h"
+
+flatbuffers::Offset<void> TileChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::TileOptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> TileChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new TileChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Tile.h b/compiler/tflchef/core/src/Op/Tile.h
new file mode 100644
index 000000000..2870ff174
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Tile.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_TILE_H__
+#define __OP_TILE_H__
+
+#include "OpChef.h"
+
+class TileChef final : public OpChef
+{
+public:
+  explicit TileChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_TILE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_TileOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct TileChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_TILE_H__
diff --git a/compiler/tflchef/core/src/Op/TopKV2.cpp b/compiler/tflchef/core/src/Op/TopKV2.cpp
new file mode 100644
index 000000000..08c4de66b
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/TopKV2.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TopKV2.h"
+
+flatbuffers::Offset<void> TopKV2Chef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::TopKV2OptionsBuilder options_builder{fbb};
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> TopKV2ChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new TopKV2Chef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/TopKV2.h b/compiler/tflchef/core/src/Op/TopKV2.h
new file mode 100644
index 000000000..554822332
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/TopKV2.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_TOPK_V2_H__
+#define __OP_TOPK_V2_H__
+
+#include "OpChef.h"
+
+class TopKV2Chef final : public OpChef
+{
+public:
+  explicit TopKV2Chef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_TOPK_V2; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_TopKV2Options; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct TopKV2ChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_TOPK_V2_H__
diff --git a/compiler/tflchef/core/src/Op/TransposeConv.cpp b/compiler/tflchef/core/src/Op/TransposeConv.cpp
new file mode 100644
index 000000000..c9e452714
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/TransposeConv.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TransposeConv.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> TransposeConvChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  tflite::TransposeConvOptionsBuilder options_builder{fbb};
+
+  assert(operation.has_transpose_conv_options());
+
+  auto tflite_padding = as_tflite_padding(operation.transpose_conv_options().padding());
+
+  options_builder.add_padding(tflite_padding);
+
+  options_builder.add_stride_h(operation.transpose_conv_options().stride_h());
+  options_builder.add_stride_w(operation.transpose_conv_options().stride_w());
+
+  return options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> TransposeConvChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new TransposeConvChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/TransposeConv.h b/compiler/tflchef/core/src/Op/TransposeConv.h
new file mode 100644
index 000000000..e664bfff2
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/TransposeConv.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_TRANSPOSE_CONV_H__
+#define __OP_TRANSPOSE_CONV_H__
+
+#include "OpChef.h"
+
+class TransposeConvChef final : public OpChef
+{
+public:
+  explicit TransposeConvChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override
+  {
+    return tflite::BuiltinOperator_TRANSPOSE_CONV;
+  }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_TransposeConvOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct TransposeConvChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_TRANSPOSE_CONV_H__
diff --git a/compiler/tflchef/core/src/Op/Unique.cpp b/compiler/tflchef/core/src/Op/Unique.cpp
new file mode 100644
index 000000000..d9a7293c5
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Unique.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Unique.h"
+#include "Convert.h"
+
+#include <cassert>
+
+flatbuffers::Offset<void> UniqueChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_unique_options());
+
+  auto tflite_out_idx = as_tflite_tensortype(operation.unique_options().idx_out_type());
+
+  tflite::UniqueOptionsBuilder unique_options_builder{fbb};
+  unique_options_builder.add_idx_out_type(tflite_out_idx);
+
+  return unique_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> UniqueChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new UniqueChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Unique.h b/compiler/tflchef/core/src/Op/Unique.h
new file mode 100644
index 000000000..58aa7bfaa
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Unique.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_UNIQUE_H__
+#define __OP_UNIQUE_H__
+
+#include "OpChef.h"
+
+class UniqueChef final : public OpChef
+{
+public:
+  explicit UniqueChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_UNIQUE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_UniqueOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct UniqueChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_UNIQUE_H__
diff --git a/compiler/tflchef/core/src/Op/Unpack.cpp b/compiler/tflchef/core/src/Op/Unpack.cpp
new file mode 100644
index 000000000..504da5a46
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Unpack.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Unpack.h"
+
+flatbuffers::Offset<void> UnpackChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_unpack_options());
+
+  tflite::UnpackOptionsBuilder unpack_options_builder{fbb};
+  unpack_options_builder.add_num(operation.unpack_options().num());
+  unpack_options_builder.add_axis(operation.unpack_options().axis());
+
+  return unpack_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> UnpackChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new UnpackChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Unpack.h b/compiler/tflchef/core/src/Op/Unpack.h
new file mode 100644
index 000000000..3a425b1a3
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Unpack.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_UNPACK_H__
+#define __OP_UNPACK_H__
+
+#include "OpChef.h"
+
+class UnpackChef final : public OpChef
+{
+public:
+  explicit UnpackChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_UNPACK; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_UnpackOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct UnpackChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ABS_H__
diff --git a/compiler/tflchef/core/src/Op/Where.cpp b/compiler/tflchef/core/src/Op/Where.cpp
new file mode 100644
index 000000000..0ce9102bc
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Where.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specwhileic language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Where.h"
+
+flatbuffers::Offset<void> WhereChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::WhereOptionsBuilder where_options_builder{fbb};
+  return where_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> WhereChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new WhereChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/Where.h b/compiler/tflchef/core/src/Op/Where.h
new file mode 100644
index 000000000..7991c64cd
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/Where.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_WHERE_H__
+#define __OP_WHERE_H__
+
+#include "OpChef.h"
+
+class WhereChef final : public OpChef
+{
+public:
+  explicit WhereChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_WHERE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_WhereOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct WhereChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_WHERE_H__
diff --git a/compiler/tflchef/core/src/Op/While.cpp b/compiler/tflchef/core/src/Op/While.cpp
new file mode 100644
index 000000000..1253d0fcc
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/While.cpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specwhileic language governing permissions and
+ * limitations under the License.
+ */
+
+#include "While.h"
+
+flatbuffers::Offset<void> WhileChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  auto &operation = (*_operation);
+
+  assert(operation.has_while_options());
+
+  tflite::WhileOptionsBuilder while_options_builder{fbb};
+  while_options_builder.add_cond_subgraph_index(operation.while_options().cond_subgraph_index());
+  while_options_builder.add_body_subgraph_index(operation.while_options().body_subgraph_index());
+
+  return while_options_builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> WhileChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new WhileChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/While.h b/compiler/tflchef/core/src/Op/While.h
new file mode 100644
index 000000000..150a14be3
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/While.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_WHILE_H__
+#define __OP_WHILE_H__
+
+#include "OpChef.h"
+
+class WhileChef final : public OpChef
+{
+public:
+  explicit WhileChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_WHILE; }
+
+  tflite::BuiltinOptions type(void) const override { return tflite::BuiltinOptions_WhileOptions; }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct WhileChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_WHILE_H__
diff --git a/compiler/tflchef/core/src/Op/ZerosLike.cpp b/compiler/tflchef/core/src/Op/ZerosLike.cpp
new file mode 100644
index 000000000..e47e2ab50
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ZerosLike.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ZerosLike.h"
+
+flatbuffers::Offset<void> ZerosLikeChef::value(flatbuffers::FlatBufferBuilder &fbb) const
+{
+  tflite::ZerosLikeOptionsBuilder builder{fbb};
+  return builder.Finish().Union();
+}
+
+std::unique_ptr<OpChef> ZerosLikeChefFactory::create(const tflchef::Operation *operation) const
+{
+  return std::unique_ptr<OpChef>{new ZerosLikeChef{operation}};
+}
diff --git a/compiler/tflchef/core/src/Op/ZerosLike.h b/compiler/tflchef/core/src/Op/ZerosLike.h
new file mode 100644
index 000000000..0af5b93e2
--- /dev/null
+++ b/compiler/tflchef/core/src/Op/ZerosLike.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __OP_ZEROS_LIKE_H__
+#define __OP_ZEROS_LIKE_H__
+
+#include "OpChef.h"
+
+class ZerosLikeChef final : public OpChef
+{
+public:
+  explicit ZerosLikeChef(const tflchef::Operation *operation) : _operation{operation}
+  {
+    // DO NOTHING
+  }
+
+public:
+  tflite::BuiltinOperator code(void) const override { return tflite::BuiltinOperator_ZEROS_LIKE; }
+
+  tflite::BuiltinOptions type(void) const override
+  {
+    return tflite::BuiltinOptions_ZerosLikeOptions;
+  }
+
+  flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const override;
+
+private:
+  const tflchef::Operation *_operation;
+};
+
+struct ZerosLikeChefFactory final : public OpChefFactory
+{
+  std::unique_ptr<OpChef> create(const tflchef::Operation *operation) const override;
+};
+
+#endif // __OP_ZEROS_LIKE_H__
diff --git a/compiler/tflchef/core/src/OpChef.def b/compiler/tflchef/core/src/OpChef.def
index a25250c46..263725a24 100644
--- a/compiler/tflchef/core/src/OpChef.def
+++ b/compiler/tflchef/core/src/OpChef.def
@@ -6,32 +6,111 @@
 // OP_CHEF(NAME, FACTORY_CLASS)
 OP_CHEF(Abs, AbsChefFactory)
 OP_CHEF(Add, AddChefFactory)
+OP_CHEF(AddN, AddNChefFactory)
 OP_CHEF(ArgMax, ArgMaxChefFactory)
-OP_CHEF(BatchToSpaceND, BatchToSpaceNDChefFactory)
+OP_CHEF(ArgMin, ArgMinChefFactory)
 OP_CHEF(AveragePool2D, AveragePool2DChefFactory)
+OP_CHEF(BatchMatMul, BatchMatMulChefFactory)
+OP_CHEF(BatchToSpaceND, BatchToSpaceNDChefFactory)
+OP_CHEF(Cast, CastChefFactory)
+OP_CHEF(Ceil, CeilChefFactory)
 OP_CHEF(Concatenation, ConcatenationChefFactory)
 OP_CHEF(Conv2D, Conv2DChefFactory)
 OP_CHEF(Cos, CosChefFactory)
+OP_CHEF(DepthToSpace, DepthToSpaceChefFactory)
 OP_CHEF(DepthwiseConv2D, DepthwiseConv2DChefFactory)
 OP_CHEF(Div, DivChefFactory)
+OP_CHEF(ELU, ELUChefFactory)
 OP_CHEF(Equal, EqualChefFactory)
 OP_CHEF(Exp, ExpChefFactory)
+OP_CHEF(ExpandDims, ExpandDimsChefFactory)
+OP_CHEF(Fill, FillChefFactory)
+OP_CHEF(Floor, FloorChefFactory)
 OP_CHEF(FloorDiv, FloorDivChefFactory)
+OP_CHEF(FloorMod, FloorModChefFactory)
 OP_CHEF(FullyConnected, FullyConnectedChefFactory)
+OP_CHEF(Gather, GatherChefFactory)
+OP_CHEF(GatherNd, GatherNdChefFactory)
+OP_CHEF(Greater, GreaterChefFactory)
+OP_CHEF(GreaterEqual, GreaterEqualChefFactory)
+OP_CHEF(If, IfChefFactory)
+OP_CHEF(L2Normalize, L2NormalizeChefFactory)
+OP_CHEF(L2Pool2D, L2Pool2DChefFactory)
+OP_CHEF(LeakyRelu, LeakyReluChefFactory)
+OP_CHEF(Less, LessChefFactory)
+OP_CHEF(LessEqual, LessEqualChefFactory)
+OP_CHEF(LocalResponseNormalization, LocalResponseNormalizationChefFactory)
+OP_CHEF(Log, LogChefFactory)
+OP_CHEF(LogicalAnd, LogicalAndChefFactory)
 OP_CHEF(LogicalNot, LogicalNotChefFactory)
 OP_CHEF(LogicalOr, LogicalOrChefFactory)
+OP_CHEF(Logistic, LogisticChefFactory)
+OP_CHEF(LogSoftmax, LogSoftmaxChefFactory)
+OP_CHEF(MatrixDiag, MatrixDiagChefFactory)
+OP_CHEF(MatrixSetDiag, MatrixSetDiagChefFactory)
+OP_CHEF(Maximum, MaximumChefFactory)
 OP_CHEF(MaxPool2D, MaxPool2DChefFactory)
 OP_CHEF(Mean, MeanChefFactory)
+OP_CHEF(Minimum, MinimumChefFactory)
+OP_CHEF(MirrorPad, MirrorPadChefFactory)
 OP_CHEF(Mul, MulChefFactory)
+OP_CHEF(Neg, NegChefFactory)
+OP_CHEF(NotEqual, NotEqualChefFactory)
+OP_CHEF(OneHot, OneHotChefFactory)
 OP_CHEF(Pack, PackChefFactory)
 OP_CHEF(Pad, PadChefFactory)
+OP_CHEF(Pow, PowChefFactory)
+OP_CHEF(PRelu, PReluChefFactory)
+OP_CHEF(Range, RangeChefFactory)
+OP_CHEF(Rank, RankChefFactory)
+OP_CHEF(ReduceAny, ReduceAnyChefFactory)
+OP_CHEF(ReduceMax, ReduceMaxChefFactory)
+OP_CHEF(ReduceMin, ReduceMinChefFactory)
+OP_CHEF(ReduceProd, ReduceProdChefFactory)
 OP_CHEF(ReLU, ReLUChefFactory)
 OP_CHEF(ReLU6, ReLU6ChefFactory)
+OP_CHEF(ReLUN1To1, ReLUN1To1ChefFactory)
 OP_CHEF(Reshape, ReshapeChefFactory)
+OP_CHEF(ResizeBilinear, ResizeBilinearChefFactory)
+OP_CHEF(ResizeNearestNeighbor, ResizeNearestNeighborChefFactory)
+OP_CHEF(ReverseSequence, ReverseSequenceChefFactory)
+OP_CHEF(ReverseV2, ReverseV2ChefFactory)
+OP_CHEF(Round, RoundChefFactory)
 OP_CHEF(Rsqrt, RsqrtChefFactory)
+OP_CHEF(ScatterNd, ScatterNdChefFactory)
+OP_CHEF(SegmentSum,SegmentSumChefFactory)
+OP_CHEF(Select, SelectChefFactory)
+OP_CHEF(SelectV2, SelectV2ChefFactory)
 OP_CHEF(Shape, ShapeChefFactory)
+OP_CHEF(Sin, SinChefFactory)
+OP_CHEF(Slice, SliceChefFactory)
 OP_CHEF(Softmax, SoftmaxChefFactory)
+OP_CHEF(SpaceToBatchND, SpaceToBatchNDChefFactory)
+OP_CHEF(SpaceToDepth, SpaceToDepthChefFactory)
+OP_CHEF(SparseToDense, SparseToDenseChefFactory)
+OP_CHEF(Split, SplitChefFactory)
+OP_CHEF(SplitV, SplitVChefFactory)
 OP_CHEF(Sqrt, SqrtChefFactory)
+OP_CHEF(Square, SquareChefFactory)
+OP_CHEF(SquaredDifference, SquaredDifferenceChefFactory)
+OP_CHEF(Squeeze, SqueezeChefFactory)
+OP_CHEF(StridedSlice, StridedSliceChefFactory)
 OP_CHEF(Sub, SubChefFactory)
+OP_CHEF(Sum, SumChefFactory)
 OP_CHEF(Tanh, TanhChefFactory)
+OP_CHEF(Tile, TileChefFactory)
+OP_CHEF(TopKV2, TopKV2ChefFactory)
 OP_CHEF(Transpose, TransposeChefFactory)
+OP_CHEF(TransposeConv, TransposeConvChefFactory)
+OP_CHEF(Unique, UniqueChefFactory)
+OP_CHEF(Unpack, UnpackChefFactory)
+OP_CHEF(Where, WhereChefFactory)
+OP_CHEF(While, WhileChefFactory)
+OP_CHEF(ZerosLike, ZerosLikeChefFactory)
+
+// Custom Op
+OP_CHEF(AddV2, AddV2ChefFactory)
+OP_CHEF(All, AllChefFactory)
+OP_CHEF(BatchMatMulV2, BatchMatMulV2ChefFactory)
+OP_CHEF(MatMul, MatMulChefFactory)
+OP_CHEF(MatrixBandPart, MatrixBandPartChefFactory)
diff --git a/compiler/tflchef/core/src/OpChef.h b/compiler/tflchef/core/src/OpChef.h
index 0b7d9cf08..7efa096cc 100644
--- a/compiler/tflchef/core/src/OpChef.h
+++ b/compiler/tflchef/core/src/OpChef.h
@@ -29,6 +29,13 @@ struct OpChef
   virtual tflite::BuiltinOperator code(void) const = 0;
   virtual tflite::BuiltinOptions type(void) const = 0;
   virtual flatbuffers::Offset<void> value(flatbuffers::FlatBufferBuilder &fbb) const = 0;
+
+  // TODO Find a way to place this method in a better place
+  virtual flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+  custom_value(flatbuffers::FlatBufferBuilder &fbb) const
+  {
+    return flatbuffers::Offset<flatbuffers::Vector<uint8_t>>();
+  }
 };
 
 struct OpChefFactory
diff --git a/compiler/tflchef/core/src/OpChefs.h b/compiler/tflchef/core/src/OpChefs.h
index 65dbd4b92..55c37ebfb 100644
--- a/compiler/tflchef/core/src/OpChefs.h
+++ b/compiler/tflchef/core/src/OpChefs.h
@@ -19,34 +19,112 @@
 
 #include "Op/Abs.h"
 #include "Op/Add.h"
+#include "Op/AddN.h"
 #include "Op/ArgMax.h"
+#include "Op/ArgMin.h"
 #include "Op/AveragePool2D.h"
+#include "Op/BatchMatMul.h"
 #include "Op/BatchToSpaceND.h"
+#include "Op/Cast.h"
+#include "Op/Ceil.h"
 #include "Op/Concatenation.h"
 #include "Op/Conv2D.h"
 #include "Op/Cos.h"
+#include "Op/DepthToSpace.h"
 #include "Op/DepthwiseConv2D.h"
 #include "Op/Div.h"
+#include "Op/ELU.h"
 #include "Op/Equal.h"
 #include "Op/Exp.h"
+#include "Op/ExpandDims.h"
+#include "Op/Fill.h"
+#include "Op/Floor.h"
 #include "Op/FloorDiv.h"
+#include "Op/FloorMod.h"
 #include "Op/FullyConnected.h"
-#include "Op/LogicalOr.h"
+#include "Op/Gather.h"
+#include "Op/GatherNd.h"
+#include "Op/Greater.h"
+#include "Op/GreaterEqual.h"
+#include "Op/If.h"
+#include "Op/L2Normalize.h"
+#include "Op/L2Pool2D.h"
+#include "Op/LeakyRelu.h"
+#include "Op/Less.h"
+#include "Op/LessEqual.h"
+#include "Op/LocalResponseNormalization.h"
+#include "Op/Log.h"
+#include "Op/LogicalAnd.h"
 #include "Op/LogicalNot.h"
+#include "Op/LogicalOr.h"
+#include "Op/Logistic.h"
+#include "Op/LogSoftmax.h"
+#include "Op/MatrixDiag.h"
+#include "Op/MatrixSetDiag.h"
+#include "Op/Maximum.h"
 #include "Op/MaxPool2D.h"
 #include "Op/Mean.h"
+#include "Op/Minimum.h"
+#include "Op/MirrorPad.h"
 #include "Op/Mul.h"
+#include "Op/Neg.h"
+#include "Op/NotEqual.h"
+#include "Op/OneHot.h"
 #include "Op/Pack.h"
 #include "Op/Pad.h"
+#include "Op/Pow.h"
+#include "Op/PRelu.h"
+#include "Op/Range.h"
+#include "Op/Rank.h"
+#include "Op/ReduceAny.h"
+#include "Op/ReduceMax.h"
+#include "Op/ReduceMin.h"
+#include "Op/ReduceProd.h"
 #include "Op/ReLU.h"
 #include "Op/ReLU6.h"
+#include "Op/ReLUN1To1.h"
 #include "Op/Reshape.h"
+#include "Op/ResizeBilinear.h"
+#include "Op/ResizeNearestNeighbor.h"
+#include "Op/ReverseSequence.h"
+#include "Op/ReverseV2.h"
+#include "Op/Round.h"
 #include "Op/Rsqrt.h"
+#include "Op/ScatterNd.h"
+#include "Op/SegmentSum.h"
+#include "Op/Select.h"
+#include "Op/SelectV2.h"
 #include "Op/Shape.h"
+#include "Op/Sin.h"
+#include "Op/Slice.h"
 #include "Op/Softmax.h"
+#include "Op/SpaceToBatchND.h"
+#include "Op/SpaceToDepth.h"
+#include "Op/SparseToDense.h"
+#include "Op/Split.h"
+#include "Op/SplitV.h"
 #include "Op/Sqrt.h"
+#include "Op/Square.h"
+#include "Op/SquaredDifference.h"
+#include "Op/Squeeze.h"
+#include "Op/StridedSlice.h"
 #include "Op/Sub.h"
+#include "Op/Sum.h"
 #include "Op/Tanh.h"
+#include "Op/Tile.h"
+#include "Op/TopKV2.h"
 #include "Op/Transpose.h"
+#include "Op/TransposeConv.h"
+#include "Op/Unique.h"
+#include "Op/Unpack.h"
+#include "Op/Where.h"
+#include "Op/While.h"
+#include "Op/ZerosLike.h"
+
+#include "CustomOp/AddV2.h"
+#include "CustomOp/All.h"
+#include "CustomOp/BatchMatMulV2.h"
+#include "CustomOp/MatMul.h"
+#include "CustomOp/MatrixBandPart.h"
 
 #endif // __OP_CHEFS_H__
diff --git a/compiler/tflchef/log/CMakeLists.txt b/compiler/tflchef/log/CMakeLists.txt
new file mode 100644
index 000000000..330459ec1
--- /dev/null
+++ b/compiler/tflchef/log/CMakeLists.txt
@@ -0,0 +1,7 @@
+# TODO Find how to test logging framework
+file(GLOB_RECURSE SOURCES "src/*.cpp")
+
+add_library(tflchef_log STATIC ${SOURCES})
+target_include_directories(tflchef_log PUBLIC include)
+target_link_libraries(tflchef_log PUBLIC hermes)
+target_link_libraries(tflchef_log PRIVATE hermes_std)
diff --git a/compiler/tflchef/log/include/Log.h b/compiler/tflchef/log/include/Log.h
new file mode 100644
index 000000000..178fe31c4
--- /dev/null
+++ b/compiler/tflchef/log/include/Log.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLCHEF_LOG_H__
+#define __TFLCHEF_LOG_H__
+
+#include <hermes.h>
+
+namespace tflchef
+{
+
+/**
+ * @brief Logger Implementation
+ */
+class Logger final : public hermes::Source
+{
+public:
+  Logger(hermes::Context *ctx);
+  ~Logger();
+};
+
+/**
+ * @brief Logger Configuration
+ *
+ * Users are able to turn logging on/off via TFLCHEF_LOG environment variable.
+ */
+class LoggerConfig final : public hermes::Config
+{
+public:
+  LoggerConfig();
+
+public:
+  void configure(const hermes::Source *, hermes::Source::Setting &) const final;
+  void configure(const Logger *, hermes::Source::Setting &) const;
+
+private:
+  bool _enabled;
+};
+
+} // namespace tflchef
+
+#include "LoggingContext.h"
+
+/**
+ * HOW TO USE:
+ *
+ *   LOGGER(l);
+ *
+ *   INFO(l) << "Hello, World" << std::endl;
+ *
+ */
+#define LOGGER(name) ::tflchef::Logger name{::tflchef::LoggingContext::get()};
+
+// TODO Support FATAL, ERROR, WARN, and VERBOSE
+#define INFO(name) HERMES_INFO(name)
+
+// WARNING!
+//
+//   THE CURRENT IMPLEMENTATION IS NOT THREAD SAFE.
+//
+
+#endif // __TFLCHEF_LOG_H__
diff --git a/compiler/tflchef/core/src/Arguments.h b/compiler/tflchef/log/include/LoggingContext.h
index 341aea6c9..860099482 100644
--- a/compiler/tflchef/core/src/Arguments.h
+++ b/compiler/tflchef/log/include/LoggingContext.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,21 +14,22 @@
  * limitations under the License.
  */
 
-#ifndef __ARGUMENTS_H__
-#define __ARGUMENTS_H__
+#ifndef __TFLCHEF_LOGGING_CONTEXT_H__
+#define __TFLCHEF_LOGGING_CONTEXT_H__
 
-#include <cstdint>
-#include <string>
+#include <hermes.h>
+
+namespace tflchef
+{
 
 /**
- * @brief Read-only string sequence view
+ * @brief Global logging context
  */
-struct Arguments
+struct LoggingContext
 {
-  virtual ~Arguments() = default;
-
-  virtual uint32_t count(void) const = 0;
-  virtual const std::string &value(uint32_t n) const = 0;
+  static hermes::Context *get(void);
 };
 
-#endif // __ARGUMENTS_H__
+} // namespace tflchef
+
+#endif // __TFLCHEF_LOGGING_CONTEXT_H__
diff --git a/compiler/tflchef/log/src/Log.cpp b/compiler/tflchef/log/src/Log.cpp
new file mode 100644
index 000000000..62c377745
--- /dev/null
+++ b/compiler/tflchef/log/src/Log.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Log.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+
+// TODO Extract these lexical conversion routines as a library
+namespace
+{
+
+/**
+ * @brief Convert C-string as a value of type T
+ *
+ * safecast(s, v) returns v if s is nullptr.
+ */
+template <typename T> T safecast(const char *, const T &);
+
+template <> bool safecast<bool>(const char *s, const bool &value)
+{
+  return (s == nullptr) ? value : (std::stoi(s) != 0);
+}
+
+} // namespace
+
+//
+// Logger
+//
+namespace tflchef
+{
+
+Logger::Logger(hermes::Context *ctx) { activate(ctx->sources(), ctx->bus()); }
+Logger::~Logger() { deactivate(); }
+
+} // namespace tflchef
+
+//
+// LoggerConfig
+//
+namespace tflchef
+{
+
+LoggerConfig::LoggerConfig()
+{
+  // Turn on logging if TFLCHEF_LOG is set as non-zero value
+  _enabled = safecast<bool>(std::getenv("TFLCHEF_LOG"), false);
+}
+
+void LoggerConfig::configure(const hermes::Source *source, hermes::Source::Setting &setting) const
+{
+  // Let's ignore hermes::Sources if that is not a moco logger
+  if (auto logger = dynamic_cast<const Logger *>(source))
+  {
+    configure(logger, setting);
+  }
+}
+
+void LoggerConfig::configure(const Logger *, hermes::Source::Setting &setting) const
+{
+  if (_enabled)
+  {
+    // Enable all catagories
+    setting.accept_all();
+  }
+  else
+  {
+    // Disable all catagories
+    setting.reject_all();
+  }
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/include/tflchef/RawModel.h b/compiler/tflchef/log/src/LoggingContext.cpp
index a8c8fefb7..0514dc38c 100644
--- a/compiler/tflchef/tflite/include/tflchef/RawModel.h
+++ b/compiler/tflchef/log/src/LoggingContext.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,28 +14,28 @@
  * limitations under the License.
  */
 
-#ifndef __RAW_MODEL_H__
-#define __RAW_MODEL_H__
+#include "LoggingContext.h"
+#include "Log.h"
 
-#include <mio/tflite/schema_generated.h>
+#include <hermes/ConsoleReporter.h>
+
+#include <memory>
 
 namespace tflchef
 {
 
-struct RawModel
+hermes::Context *LoggingContext::get(void)
 {
-  virtual ~RawModel() = default;
+  static hermes::Context *ctx = nullptr;
 
-  virtual const ::tflite::Model *model(void) const = 0;
-};
+  if (ctx == nullptr)
+  {
+    ctx = new hermes::Context;
+    ctx->sinks()->append(std::make_unique<hermes::ConsoleReporter>());
+    ctx->config(std::make_unique<LoggerConfig>());
+  }
 
-/**
- * @brief Load TensorFlow Lite model (as a RawModel) from a given path
- *
- * @note May return a nullptr
- */
-std::unique_ptr<RawModel> load_tflite(const std::string &path);
+  return ctx;
+}
 
 } // namespace tflchef
-
-#endif // __RAW_MODEL_H__
diff --git a/compiler/tflchef/proto/tflchef.proto b/compiler/tflchef/proto/tflchef.proto
index 486aa8a67..792503bc9 100644
--- a/compiler/tflchef/proto/tflchef.proto
+++ b/compiler/tflchef/proto/tflchef.proto
@@ -55,15 +55,24 @@ enum Padding {
 enum Activation {
   NONE = 0;
   RELU = 1;
+  RELU_N1_TO_1 = 2;
   RELU6 = 3;
 }
 
+// This enum value corresponds to MirrorPadMode in TensorFlow Lite schema
+enum MirrorPadMode {
+  REFLECT = 0;
+  SYMMETRIC = 1;
+}
+
 message Conv2DOptions
 {
   optional Padding padding = 1 [default = VALID];
   optional int32 stride_w = 2 [default = 1];
   optional int32 stride_h = 3 [default = 1];
   optional Activation activation = 4 [default = NONE];
+  optional int32 dilation_w_factor = 5 [default = 1];
+  optional int32 dilation_h_factor = 6 [default = 1];
 }
 
 message Pool2DOptions {
@@ -91,6 +100,12 @@ message DepthwiseConv2DOptions
   optional int32 stride_h = 3 [default = 1];
   optional int32 depth_multiplier = 4 [default = 1];
   optional Activation activation = 5 [default = NONE];
+  optional int32 dilation_w_factor = 6 [default = 1];
+  optional int32 dilation_h_factor = 7 [default = 1];
+}
+
+message ScatterNdOptions {
+  // None
 }
 
 message SubOptions {
@@ -105,6 +120,10 @@ message FloorDivOptions {
   // None
 }
 
+message FloorModOptions {
+  // None
+}
+
 message FullyConnectedOptions {
   optional Activation activation = 1 [default = NONE];
 }
@@ -113,10 +132,18 @@ message AddOptions {
   optional Activation activation = 1 [default = NONE];
 }
 
+message AddNOptions {
+  // None
+}
+
 message ArgMaxOptions {
   optional TensorType output_type = 1 [default = INT64];
 }
 
+message ArgMinOptions {
+  optional TensorType output_type = 1 [default = INT64];
+}
+
 message PackOptions {
   optional int32 values_count = 1;
   optional int32 axis = 2 [default = 0];
@@ -126,6 +153,10 @@ message PadOptions {
   // None
 }
 
+message MirrorPadOptions {
+  optional MirrorPadMode mode = 1 [default = REFLECT];
+}
+
 message SoftmaxOptions {
   optional float beta = 1 [default = 0.0];
 }
@@ -134,10 +165,22 @@ message MulOptions {
   optional Activation activation = 1 [default = NONE];
 }
 
+message NegOptions {
+  // None
+}
+
+message RangeOptions {
+  // None
+}
+
 message ReducerOptions {
   optional bool keep_dims = 1 [ default = false ];
 }
 
+message SpaceToDepthOptions {
+  optional int32 block_size = 1;
+}
+
 message LogicalOrOptions {
   // None
 }
@@ -174,14 +217,224 @@ message BatchToSpaceNDOptions {
   // None
 }
 
+message SpaceToBatchNDOptions {
+  // None
+}
+
+message StridedSliceOptions {
+  optional int32 begin_mask = 1;
+  optional int32 end_mask = 2;
+  optional int32 ellipsis_mask = 3;
+  optional int32 new_axis_mask = 4;
+  optional int32 shrink_axis_mask = 5;
+}
+
+message SliceOptions {
+  // None
+}
+
 message ExpOptions {
   // None
 }
 
+message ExpandDimsOptions {
+  // None
+}
+
+message UnpackOptions {
+  optional int32 num = 1;
+  optional int32 axis = 2 [default = 0];
+}
+
+message GatherOptions {
+  optional int32 axis = 1 [default = 0];
+}
+
+message TileOptions {
+  // None
+}
+
+message BatchMatMulOptions {
+  optional bool adj_x = 1 [default = false];
+  optional bool adj_y = 2 [default = false];
+}
+
+message IfOptions {
+  optional int32 then_subgraph_index = 1;
+  optional int32 else_subgraph_index = 2;
+}
+
+message WhileOptions {
+  optional int32 cond_subgraph_index = 1;
+  optional int32 body_subgraph_index = 2;
+}
+
+message CastOptions {
+  optional TensorType in_data_type = 1 [default = FLOAT32];
+  optional TensorType out_data_type = 2 [default = FLOAT32];
+}
+
+message SquareOptions {
+  // None
+}
+
+message MaximumMinimumOptions {
+  //None
+}
+
+message GreaterEqualOptions {
+  // None
+}
+
+message SelectOptions {
+  // None
+}
+
+message SelectV2Options {
+  // None
+}
+
+message SplitOptions {
+  optional int32 num_splits = 1;
+}
+
+message SplitVOptions {
+  optional int32 num_splits = 1;
+}
+
+message SquaredDifferenceOptions {
+  // None
+}
+
+message FillOptions {
+  // None
+}
+
+message GreaterOptions {
+  // None 
+}
+
+message L2NormOptions {
+  optional Activation activation = 1 [default = NONE];
+}
+
+message LessOptions {
+  // None
+}
+
+message LessEqualOptions {
+  // None
+}
+
+message LocalResponseNormalizationOptions {
+  optional int32 radius = 1 [default = 5];
+  optional float bias = 2 [default = 1.0];
+  optional float alpha = 3 [default = 1.0];
+  optional float beta = 4 [default = 0.5];
+}
+
+message MatMulOptions {
+  optional bool transpose_a = 1 [default = false];
+  optional bool transpose_b = 2 [default = false];
+}
+
+message SqueezeOptions {
+  repeated int32 squeeze_dim = 1;
+}
+
+message OneHotOptions {
+  optional int32 axis = 1 [default = -1];
+}
+
+message TopKV2Options {
+  // None
+}
+
+message LogSoftmaxOptions {
+  // None
+}
+
+message ZerosLikeOptions {
+  // None
+}
+
+message GatherNdOptions {
+  // None
+}
+
+message NotEqualOptions {
+  // None
+}
+
+message PowOptions {
+  // None
+}
+
+message LeakyReluOptions {
+  optional float alpha = 1 [default = 0.2];
+}
+
+message ResizeNearestNeighborOptions {
+  optional bool align_corners = 1 [default = false];
+}
+
+message ResizeBilinearOptions {
+  optional bool align_corners = 1 [default = false];
+  optional bool half_pixel_centers = 2 [default = false];
+}
+
+message DepthToSpaceOptions {
+  optional int32 block_size = 1;
+}
+
+message TransposeConvOptions {
+  optional Padding padding = 1 [default = VALID];
+  optional int32 stride_w = 2 [default = 1];
+  optional int32 stride_h = 3 [default = 1];
+}
+
+message ReverseSequenceOptions {
+  optional int32 seq_dim = 1 [default = 0];
+  optional int32 batch_dim = 2 [default = 0];
+}
+
+message RankOptions {
+  // NONE
+}
+
+message SegmentSumOptions {
+  // NONE
+}
+
+message UniqueOptions {
+  optional TensorType idx_out_type = 1 [default = INT32];
+}
+
+message WhereOptions {
+ // None
+}
+
+message SparseToDenseOptions {
+  optional bool validate_indices = 1 [default = true];
+}
+
+message ReverseV2Options {
+  // None
+}
+
+message MatrixDiagOptions {
+  // NONE
+}
+
+message MatrixSetDiagOptions {
+  // NONE
+}
+
 message Operation {
   optional string type = 1;
   repeated string input = 2;
   repeated string output = 3;
+  optional int32 version = 4 [default = 1];
 
   optional Conv2DOptions conv2d_options = 100;
   optional Pool2DOptions averagepool2d_options = 101;
@@ -210,6 +463,91 @@ message Operation {
   optional FloorDivOptions floordiv_options = 124;
   optional BatchToSpaceNDOptions batch_to_space_options = 125;
   optional ExpOptions exp_options = 126;
+  optional UnpackOptions unpack_options = 127;
+  optional GatherOptions gather_options = 128;
+  optional BatchMatMulOptions batch_matmul_options = 129;
+  optional TileOptions tile_options = 130;
+  optional IfOptions if_options = 131;
+  optional WhileOptions while_options = 132;
+  optional SpaceToBatchNDOptions space_to_batch_nd_options = 133;
+  optional CastOptions cast_options = 134;
+  optional GreaterEqualOptions greaterequal_options = 135;
+  optional MaximumMinimumOptions maximum_options = 136;
+  optional StridedSliceOptions strided_slice_options = 137;
+  optional SquaredDifferenceOptions squared_difference_options = 138;
+  optional FillOptions fill_options = 139;
+  optional SelectOptions select_options = 140;
+  optional ReducerOptions reduce_prod_options = 141;
+  optional SplitOptions split_options = 142;
+  optional SplitVOptions split_v_options = 143;
+  optional ReducerOptions sum_options = 144;
+  optional GreaterOptions greater_options = 145;
+  optional SqueezeOptions squeeze_options = 146;
+  optional FloorModOptions floormod_options = 147;
+  optional OneHotOptions onehot_options = 148;
+  optional LessOptions less_options = 149;
+  optional ReducerOptions reduce_max_options = 150;
+  optional MaximumMinimumOptions minimum_options = 151;
+  optional ReducerOptions reduce_any_options = 152;
+  optional ZerosLikeOptions zeros_like_options = 153;
+  // ConcatEmbeddingsOptions 154
+  // LSHProjectionOptions 155
+  // SVDFOptions 156
+  // RNNOptions 157
+  optional L2NormOptions l2norm_options = 158;
+  optional LocalResponseNormalizationOptions local_response_normalization_options = 159;
+  // LSTMOptions 160
+  optional ResizeBilinearOptions resize_bilinear_options = 161;
+  // CallOptions 162
+  // SkipGramOptions 163
+  optional SpaceToDepthOptions space_to_depth_options = 164;
+  // EmbeddingLookupSparseOptions 165
+  // SequenceRNNOptions 166
+  optional TopKV2Options topk_v2_options = 167;
+  optional LogSoftmaxOptions log_softmax_options = 168;
+  // DequantizeOptions 169
+  optional NegOptions neg_options = 170;
+  // PadV2Options 171
+  optional LessEqualOptions lessequal_options = 172;
+  optional SliceOptions slice_options = 173;
+  optional TransposeConvOptions transpose_conv_options = 174;
+  optional SparseToDenseOptions sparse_to_dense_options = 175;
+  optional PowOptions pow_options = 176;
+  optional ArgMinOptions argmin_options = 177;
+  // FakeQuantOptions 178
+  // BidirectionalSequenceLSTMOptions 179
+  // BidirectionalSequenceRNNOptions 180
+  // UnidirectionalSequenceLSTMOptions 181
+  optional RangeOptions range_options = 182;
+  optional ResizeNearestNeighborOptions resize_nearest_neighbor_options = 183;
+  optional LeakyReluOptions leaky_relu_options = 184;
+  optional MirrorPadOptions mirrorpad_options = 185;
+  optional UniqueOptions unique_options = 186;
+  optional ReverseV2Options reversev2_options = 187;
+  // AddNOptions 188
+  optional GatherNdOptions gather_nd_options = 189;
+  optional WhereOptions where_options = 190;
+  optional RankOptions rank_options = 191;
+  optional ReverseSequenceOptions reverse_sequence_options = 192;
+  optional MatrixDiagOptions matrix_diag_options = 193;
+  // QuantizeOptions 194
+  optional MatrixSetDiagOptions matrix_set_diag_options = 195;
+  // HardSwishOptions 196
+  optional DepthToSpaceOptions depth_to_space_options = 197;
+  // NonMaxSuppressionV4Options 198
+  // NonMaxSuppressionV5Options 199
+  optional ScatterNdOptions scatter_nd_options = 200;
+  optional NotEqualOptions notequal_options = 201;
+  optional ExpandDimsOptions expand_dims_options = 202;
+  optional Pool2DOptions l2pool2d_options = 203;
+  optional ReducerOptions all_options = 204;
+  optional ReducerOptions reduce_min_options = 205;
+  optional SegmentSumOptions segment_sum_options = 206;
+  optional AddNOptions add_n_options = 207;
+  optional MatMulOptions matmul_options = 208;
+
+  // NOTE if there are more than two options with same type of Options
+  // use the number not listed in the above reserve list
 }
 
 // For additional subgraphs
diff --git a/compiler/tflchef/requires.cmake b/compiler/tflchef/requires.cmake
index 3c5bb197f..4c02174b5 100644
--- a/compiler/tflchef/requires.cmake
+++ b/compiler/tflchef/requires.cmake
@@ -1,4 +1,9 @@
+require("arser")
 require("nnkit")
 require("cwrap")
 require("mio-tflite")
 require("safemain")
+require("hermes")
+require("hermes-std")
+require("foder")
+require("souschef")
diff --git a/compiler/tflchef/tests/no_shape/test.recipe b/compiler/tflchef/tests/no_shape/test.recipe
new file mode 100644
index 000000000..38efef96a
--- /dev/null
+++ b/compiler/tflchef/tests/no_shape/test.recipe
@@ -0,0 +1,43 @@
+operand {
+  name: "indices"
+  type: INT32
+  shape { dim: 4 }
+}
+operand {
+  name: "depth"
+  type: INT32
+  # shape is intentionally omitted here
+  filler { tag: "explicit" arg: "1" }
+}
+operand {
+  name: "on_value"
+  type: INT32
+  # shape is intentionally omitted here
+  filler { tag: "explicit" arg: "1" }
+}
+operand {
+  name: "off_value"
+  type: INT32
+  # shape is intentionally omitted here
+  filler { tag: "explicit" arg: "0" }
+}
+operand {
+  name: "ofm"
+  type: INT32
+  shape { dim: 4 dim: 1 }
+}
+operation {
+  type: "OneHot"
+  onehot_options {
+    axis: -1
+  }
+  input: "indices"
+  input: "depth"
+  input: "on_value"
+  input: "off_value"
+  output: "ofm"
+}
+input: "indices"
+input: "on_value"
+input: "off_value"
+output: "ofm"
diff --git a/compiler/tflchef/tests/no_shape/test.reverse b/compiler/tflchef/tests/no_shape/test.reverse
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/compiler/tflchef/tests/no_shape/test.reverse
diff --git a/compiler/tflchef/tests/runvalidate.sh b/compiler/tflchef/tests/runvalidate.sh
index a1453b399..0dd9d16e0 100755
--- a/compiler/tflchef/tests/runvalidate.sh
+++ b/compiler/tflchef/tests/runvalidate.sh
@@ -1,13 +1,13 @@
 #!/bin/bash
 
-if [[ $# -le 3 ]]; then
+if [[ $# -le 2 ]]; then
   echo "USAGE: $0 [mio_tflite_validate path] [prefix 0] "
   exit 255
 fi
 
 MIO_TFLITE_VALIDATE_PATH="$1"; shift
 
-echo "-- Found mio_tflite_validate: ${NNKIT_RUN_PATH}"
+echo "-- Found mio_tflite_validate: ${MIO_TFLITE_VALIDATE_PATH}"
 
 TESTED=()
 PASSED=()
diff --git a/compiler/tflchef/tflite/src/Convert.cpp b/compiler/tflchef/tflite/src/Convert.cpp
index dc60e0087..3cc1c9238 100644
--- a/compiler/tflchef/tflite/src/Convert.cpp
+++ b/compiler/tflchef/tflite/src/Convert.cpp
@@ -51,10 +51,11 @@ tflchef::Activation as_tflchef_activation(const tflite::ActivationFunctionType t
       return tflchef::NONE;
     case tflite::ActivationFunctionType_RELU:
       return tflchef::RELU;
+    case tflite::ActivationFunctionType_RELU_N1_TO_1:
+      return tflchef::RELU_N1_TO_1;
     case tflite::ActivationFunctionType_RELU6:
       return tflchef::RELU6;
     // TODO handle other types
-    // ActivationFunctionType_RELU_N1_TO_1
     // ActivationFunctionType_TANH
     // ActivationFunctionType_SIGN_BIT
     default:
@@ -75,4 +76,17 @@ tflchef::Padding as_tflchef_padding(const tflite::Padding padding)
   }
 }
 
+tflchef::MirrorPadMode as_tflchef_mirrorpadmode(const tflite::MirrorPadMode mode)
+{
+  switch (mode)
+  {
+    case tflite::MirrorPadMode_REFLECT:
+      return tflchef::REFLECT;
+    case tflite::MirrorPadMode_SYMMETRIC:
+      return tflchef::SYMMETRIC;
+    default:
+      throw std::runtime_error{"Unknown mirrorpad mode"};
+  }
+}
+
 } // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Convert.h b/compiler/tflchef/tflite/src/Convert.h
index 8623e7b78..770bffa4d 100644
--- a/compiler/tflchef/tflite/src/Convert.h
+++ b/compiler/tflchef/tflite/src/Convert.h
@@ -27,12 +27,14 @@ namespace tflchef
 tflchef::TensorType as_tflchef_type(const tflite::TensorType type);
 tflchef::Activation as_tflchef_activation(const tflite::ActivationFunctionType type);
 tflchef::Padding as_tflchef_padding(const tflite::Padding padding);
+tflchef::MirrorPadMode as_tflchef_mirrorpadmode(const tflite::MirrorPadMode mode);
 
 /**
  * @brief extract buffer data to std::vector<DT>
  */
 template <typename DT> std::vector<DT> extract_buffer(const tflite::Buffer *buffer)
 {
+  assert(buffer->data() != nullptr);
   auto buffer_length = buffer->data()->size();
   auto num_elements = buffer_length / sizeof(DT);
   std::vector<DT> result(num_elements);
diff --git a/compiler/tflchef/tflite/src/FillerHelper.cpp b/compiler/tflchef/tflite/src/FillerHelper.cpp
new file mode 100644
index 000000000..cf96d2e8c
--- /dev/null
+++ b/compiler/tflchef/tflite/src/FillerHelper.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FillerHelper.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void fill_tensor_to_import(int32_t idx, TFliteImport *import)
+{
+  const tflite::Tensor *tensor = import->tensors()->Get(idx);
+  if (tensor != nullptr)
+  {
+    if (tensor->type() == tflite::TensorType::TensorType_INT32)
+    {
+      const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+      if (buffer && buffer->data())
+      {
+        auto vec = extract_buffer<int32_t>(buffer);
+        import->set_tensor_filler(idx, vec);
+      }
+    }
+    else if (tensor->type() == tflite::TensorType::TensorType_FLOAT32)
+    {
+      const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+      if (buffer && buffer->data())
+      {
+        auto vec = extract_buffer<float>(buffer);
+        import->set_tensor_filler(idx, vec);
+      }
+    }
+  }
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/core/src/DataChefs.h b/compiler/tflchef/tflite/src/FillerHelper.h
index 2310ae89d..053a5c18a 100644
--- a/compiler/tflchef/core/src/DataChefs.h
+++ b/compiler/tflchef/tflite/src/FillerHelper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,11 +14,18 @@
  * limitations under the License.
  */
 
-#ifndef __DATA_CHEFS_H__
-#define __DATA_CHEFS_H__
+#ifndef __FILLER_HELPER_H__
+#define __FILLER_HELPER_H__
 
-#include "Data/Constant.h"
-#include "Data/Explicit.h"
-#include "Data/Gaussian.h"
+#include "TFliteImport.h"
 
-#endif // __DATA_CHEFS_H__
+#include <mio/tflite/schema_generated.h>
+
+namespace tflchef
+{
+
+void fill_tensor_to_import(int32_t idx, TFliteImport *import);
+
+} // namespace tflchef
+
+#endif // __FILLER_HELPER_H__
diff --git a/compiler/tflchef/tflite/src/Op/Add.cpp b/compiler/tflchef/tflite/src/Op/Add.cpp
index 7e669ecc9..3e880a63b 100644
--- a/compiler/tflchef/tflite/src/Op/Add.cpp
+++ b/compiler/tflchef/tflite/src/Op/Add.cpp
@@ -17,6 +17,7 @@
 #include "Add.h"
 
 #include "Convert.h"
+#include "FillerHelper.h"
 
 namespace tflchef
 {
@@ -24,7 +25,13 @@ namespace tflchef
 void TFliteOpAdd::filler(const tflite::Operator *op, TFliteImport *import,
                          tflchef::ModelRecipe *model_recipe) const
 {
-  // Nothing to do with filler
+  // Add may have constant input
+
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+  assert(inputs.size() == 2);
+
+  fill_tensor_to_import(inputs[0], import);
+  fill_tensor_to_import(inputs[1], import);
 }
 
 tflchef::Operation *TFliteOpAdd::build(const tflite::Operator *op, TFliteImport *import,
diff --git a/compiler/tflchef/tflite/src/Op/AddN.cpp b/compiler/tflchef/tflite/src/Op/AddN.cpp
new file mode 100644
index 000000000..aeb3803ab
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/AddN.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "AddN.h"
+
+#include "Convert.h"
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpAddN::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  // AddN may have constant input
+
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+
+  for (uint32_t idx = 0; idx < inputs.size(); ++idx)
+    fill_tensor_to_import(inputs[idx], import);
+}
+
+tflchef::Operation *TFliteOpAddN::build(const tflite::Operator *op, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("AddN");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/AddN.h b/compiler/tflchef/tflite/src/Op/AddN.h
new file mode 100644
index 000000000..4387aa06a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/AddN.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ADD_N_H__
+#define __TFLITE_OP_ADD_N_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for AddN
+ */
+class TFliteOpAddN : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ADD_N_H__
diff --git a/compiler/tflchef/tflite/src/Op/ArgMin.cpp b/compiler/tflchef/tflite/src/Op/ArgMin.cpp
new file mode 100644
index 000000000..faab0b830
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ArgMin.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ArgMin.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpArgMin::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input, argmin/dim
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *dim_tensor = import->tensors()->Get(inputs[1]);
+  assert(dim_tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(dim_tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpArgMin::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ArgMinOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ArgMin");
+
+  auto op_options = operation->mutable_argmin_options();
+
+  op_options->set_output_type(as_tflchef_type(op_params->output_type()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ArgMin.h b/compiler/tflchef/tflite/src/Op/ArgMin.h
new file mode 100644
index 000000000..83c643c1a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ArgMin.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ARGMIN_H__
+#define __TFLITE_OP_ARGMIN_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ArgMin
+ */
+class TFliteOpArgMin : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ARGMIN_H__
diff --git a/compiler/tflchef/tflite/src/Op/BatchMatMul.cpp b/compiler/tflchef/tflite/src/Op/BatchMatMul.cpp
new file mode 100644
index 000000000..598e58c94
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/BatchMatMul.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BatchMatMul.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpBatchMatMul::filler(const tflite::Operator *op, TFliteImport *import,
+                                 tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpBatchMatMul::build(const tflite::Operator *op, TFliteImport *import,
+                                               tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("BatchMatMul");
+
+  auto op_options = operation->mutable_batch_matmul_options();
+
+  auto op_params = op->builtin_options_as_BatchMatMulOptions();
+  assert(op_params != nullptr);
+
+  op_options->set_adj_x(op_params->adj_x());
+  op_options->set_adj_y(op_params->adj_y());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/BatchMatMul.h b/compiler/tflchef/tflite/src/Op/BatchMatMul.h
new file mode 100644
index 000000000..6eb4c6e68
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/BatchMatMul.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_BATCHMATMUL_H__
+#define __TFLITE_OP_BATCHMATMUL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for BATCH_MATMUL
+ */
+class TFliteOpBatchMatMul : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_BATCHMATMUL_H__
diff --git a/compiler/tflchef/tflite/src/Op/Cast.cpp b/compiler/tflchef/tflite/src/Op/Cast.cpp
new file mode 100644
index 000000000..393bb4b35
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Cast.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Cast.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpCast::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpCast::build(const tflite::Operator *op, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_CastOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Cast");
+
+  auto op_options = operation->mutable_cast_options();
+
+  op_options->set_in_data_type(as_tflchef_type(op_params->in_data_type()));
+  op_options->set_out_data_type(as_tflchef_type(op_params->out_data_type()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Cast.h b/compiler/tflchef/tflite/src/Op/Cast.h
new file mode 100644
index 000000000..29c126c93
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Cast.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_CAST_H__
+#define __TFLITE_OP_CAST_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for CAST
+ */
+class TFliteOpCast : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_CAST_H__
diff --git a/compiler/tflchef/tflite/src/Op/Ceil.cpp b/compiler/tflchef/tflite/src/Op/Ceil.cpp
new file mode 100644
index 000000000..d3ef3adae
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Ceil.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Ceil.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpCeil::filler(const tflite::Operator *, TFliteImport *, tflchef::ModelRecipe *) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpCeil::build(const tflite::Operator *, TFliteImport *,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Ceil");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Ceil.h b/compiler/tflchef/tflite/src/Op/Ceil.h
new file mode 100644
index 000000000..44df20778
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Ceil.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_CEIL_H__
+#define __TFLITE_OP_CEIL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for CEIL
+ */
+class TFliteOpCeil : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_CEIL_H__
diff --git a/compiler/tflchef/tflite/src/Op/Conv2D.cpp b/compiler/tflchef/tflite/src/Op/Conv2D.cpp
index 5d48ee24f..57abd4649 100644
--- a/compiler/tflchef/tflite/src/Op/Conv2D.cpp
+++ b/compiler/tflchef/tflite/src/Op/Conv2D.cpp
@@ -50,7 +50,8 @@ tflchef::Operation *TFliteOpConv2D::build(const tflite::Operator *op, TFliteImpo
   op_options->set_stride_h(op_params->stride_h());
   op_options->set_stride_w(op_params->stride_w());
   op_options->set_padding(as_tflchef_padding(op_params->padding()));
-  // TODO support dilation
+  op_options->set_dilation_w_factor(op_params->dilation_w_factor());
+  op_options->set_dilation_h_factor(op_params->dilation_h_factor());
 
   return operation;
 }
diff --git a/compiler/tflchef/tflite/src/Op/DepthToSpace.cpp b/compiler/tflchef/tflite/src/Op/DepthToSpace.cpp
new file mode 100644
index 000000000..1a0917e8e
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/DepthToSpace.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "DepthToSpace.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpDepthToSpace::filler(const tflite::Operator *op, TFliteImport *import,
+                                  tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpDepthToSpace::build(const tflite::Operator *op, TFliteImport *import,
+                                                tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("DepthToSpace");
+
+  auto op_params = op->builtin_options_as_DepthToSpaceOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_depth_to_space_options();
+
+  op_options->set_block_size(op_params->block_size());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/DepthToSpace.h b/compiler/tflchef/tflite/src/Op/DepthToSpace.h
new file mode 100644
index 000000000..b5852ac89
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/DepthToSpace.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_DEPTHTOSPACE_H__
+#define __TFLITE_OP_DEPTHTOSPACE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for DepthToSpace
+ */
+class TFliteOpDepthToSpace : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_DEPTHTOSPACE_H__
diff --git a/compiler/tflchef/tflite/src/Op/DepthwiseConv2D.cpp b/compiler/tflchef/tflite/src/Op/DepthwiseConv2D.cpp
index b19f9330f..5fed3353a 100644
--- a/compiler/tflchef/tflite/src/Op/DepthwiseConv2D.cpp
+++ b/compiler/tflchef/tflite/src/Op/DepthwiseConv2D.cpp
@@ -50,9 +50,8 @@ tflchef::Operation *TFliteOpDepthwiseConv2D::build(const tflite::Operator *op, T
   op_options->set_stride_h(op_params->stride_h());
   op_options->set_stride_w(op_params->stride_w());
   op_options->set_depth_multiplier(op_params->depth_multiplier());
-  // TODO support dilation
-  // op_params->dilation_w_factor()
-  // op_params->dilation_h_factor()
+  op_options->set_dilation_w_factor(op_params->dilation_w_factor());
+  op_options->set_dilation_h_factor(op_params->dilation_h_factor());
   op_options->set_padding(as_tflchef_padding(op_params->padding()));
 
   return operation;
diff --git a/compiler/tflchef/tflite/src/Op/ELU.cpp b/compiler/tflchef/tflite/src/Op/ELU.cpp
new file mode 100644
index 000000000..cb4b61d66
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ELU.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELU.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpELU::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpELU::build(const tflite::Operator *, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ELU");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ELU.h b/compiler/tflchef/tflite/src/Op/ELU.h
new file mode 100644
index 000000000..490c9fde4
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ELU.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ELU_H__
+#define __TFLITE_OP_ELU_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ELU
+ */
+class TFliteOpELU : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ELU_H__
diff --git a/compiler/tflchef/tflite/src/Op/ExpandDims.cpp b/compiler/tflchef/tflite/src/Op/ExpandDims.cpp
new file mode 100644
index 000000000..e30e8dbcc
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ExpandDims.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ExpandDims.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpExpandDims::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Fill for axis input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpExpandDims::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ExpandDims");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ExpandDims.h b/compiler/tflchef/tflite/src/Op/ExpandDims.h
new file mode 100644
index 000000000..e2f3e4e50
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ExpandDims.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_EXPAND_DIMS_H__
+#define __TFLITE_OP_EXPAND_DIMS_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ExpandDims
+ */
+class TFliteOpExpandDims : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_EXPAND_DIMS_H__
diff --git a/compiler/tflchef/tflite/src/Op/Fill.cpp b/compiler/tflchef/tflite/src/Op/Fill.cpp
new file mode 100644
index 000000000..08b695fd7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Fill.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Fill.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpFill::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *dims_tensor = import->tensors()->Get(inputs[0]);
+  assert(dims_tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(dims_tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[0], vec);
+}
+
+tflchef::Operation *TFliteOpFill::build(const tflite::Operator *op, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("Fill");
+
+  // FillOptions are empty
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Fill.h b/compiler/tflchef/tflite/src/Op/Fill.h
new file mode 100644
index 000000000..4f46f628a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Fill.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_FILL_H__
+#define __TFLITE_OP_FILL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Fill
+ */
+class TFliteOpFill : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_FILL_H__
diff --git a/compiler/tflchef/tflite/src/Op/Floor.cpp b/compiler/tflchef/tflite/src/Op/Floor.cpp
new file mode 100644
index 000000000..373c69f71
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Floor.cpp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Floor.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpFloor::filler(const tflite::Operator *, TFliteImport *, tflchef::ModelRecipe *) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpFloor::build(const tflite::Operator *, TFliteImport *,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Floor");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Floor.h b/compiler/tflchef/tflite/src/Op/Floor.h
new file mode 100644
index 000000000..f0f8ef38a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Floor.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_FLOOR_H__
+#define __TFLITE_OP_FLOOR_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for FLOOR
+ */
+class TFliteOpFloor : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_FLOOR_H__
diff --git a/compiler/tflchef/tflite/src/Op/FloorMod.cpp b/compiler/tflchef/tflite/src/Op/FloorMod.cpp
new file mode 100644
index 000000000..997d82664
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/FloorMod.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FloorMod.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpFloorMod::filler(const tflite::Operator *op, TFliteImport *import,
+                              tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpFloorMod::build(const tflite::Operator *op, TFliteImport *import,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("FloorMod");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/FloorMod.h b/compiler/tflchef/tflite/src/Op/FloorMod.h
new file mode 100644
index 000000000..f36dfe813
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/FloorMod.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_FLOOR_MOD_H__
+#define __TFLITE_OP_FLOOR_MOD_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for FLOOR_MOD
+ */
+class TFliteOpFloorMod : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_FLOOR_MOD_H__
diff --git a/compiler/tflchef/tflite/src/Op/Gather.cpp b/compiler/tflchef/tflite/src/Op/Gather.cpp
new file mode 100644
index 000000000..98da3ec43
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Gather.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Gather.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpGather::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+  // But second input has filler for constant inputs
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[1], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpGather::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_GatherOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Gather");
+
+  auto op_options = operation->mutable_gather_options();
+
+  op_options->set_axis(op_params->axis());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Gather.h b/compiler/tflchef/tflite/src/Op/Gather.h
new file mode 100644
index 000000000..e01276b76
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Gather.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_GATHER_H__
+#define __TFLITE_OP_GATHER_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Gather
+ */
+class TFliteOpGather : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_GATHER_H__
diff --git a/compiler/tflchef/tflite/src/Op/GatherNd.cpp b/compiler/tflchef/tflite/src/Op/GatherNd.cpp
new file mode 100644
index 000000000..0ff5a0b7f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/GatherNd.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GatherNd.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpGatherNd::filler(const tflite::Operator *op, TFliteImport *import,
+                              tflchef::ModelRecipe *model_recipe) const
+{
+  // indices buffer has filler
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[1], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpGatherNd::build(const tflite::Operator *op, TFliteImport *import,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("GatherNd");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/GatherNd.h b/compiler/tflchef/tflite/src/Op/GatherNd.h
new file mode 100644
index 000000000..112f23d33
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/GatherNd.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_GATHER_ND_H__
+#define __TFLITE_OP_GATHER_ND_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for GatherNd
+ */
+class TFliteOpGatherNd : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_GATHER_ND_H__
diff --git a/compiler/tflchef/tflite/src/Op/Greater.cpp b/compiler/tflchef/tflite/src/Op/Greater.cpp
new file mode 100644
index 000000000..4e41efb2d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Greater.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Greater.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpGreater::filler(const tflite::Operator *op, TFliteImport *import,
+                             tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpGreater::build(const tflite::Operator *op, TFliteImport *import,
+                                           tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Greater");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Greater.h b/compiler/tflchef/tflite/src/Op/Greater.h
new file mode 100644
index 000000000..3ab2d1a4e
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Greater.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_GREATER_H__
+#define __TFLITE_OP_GREATER_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Greater
+ */
+class TFliteOpGreater : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_GREATER_H__
diff --git a/compiler/tflchef/tflite/src/Op/GreaterEqual.cpp b/compiler/tflchef/tflite/src/Op/GreaterEqual.cpp
new file mode 100644
index 000000000..aead30e57
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/GreaterEqual.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GreaterEqual.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpGreaterEqual::filler(const tflite::Operator *op, TFliteImport *import,
+                                  tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpGreaterEqual::build(const tflite::Operator *op, TFliteImport *import,
+                                                tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("GreaterEqual");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/GreaterEqual.h b/compiler/tflchef/tflite/src/Op/GreaterEqual.h
new file mode 100644
index 000000000..96b0af78a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/GreaterEqual.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_GREATEREQUAL_H__
+#define __TFLITE_OP_GREATEREQUAL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Greater Equal
+ */
+class TFliteOpGreaterEqual : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_GREATEREQUAL_H__
diff --git a/compiler/tflchef/tflite/src/Op/L2Normalize.cpp b/compiler/tflchef/tflite/src/Op/L2Normalize.cpp
new file mode 100644
index 000000000..0a8908472
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/L2Normalize.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "L2Normalize.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpL2Normalize::filler(const tflite::Operator *op, TFliteImport *import,
+                                 tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpL2Normalize::build(const tflite::Operator *op, TFliteImport *import,
+                                               tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_L2NormOptions();
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("L2Normalize");
+
+  auto op_options = operation->mutable_l2norm_options();
+
+  op_options->set_activation(as_tflchef_activation(op_params->fused_activation_function()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/L2Normalize.h b/compiler/tflchef/tflite/src/Op/L2Normalize.h
new file mode 100644
index 000000000..a73eae6c8
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/L2Normalize.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_L2NORMALIZE_H__
+#define __TFLITE_OP_L2NORMALIZE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for L2Normalize
+ */
+class TFliteOpL2Normalize : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_L2NORMALIZE_H__
diff --git a/compiler/tflchef/tflite/src/Op/L2Pool2D.cpp b/compiler/tflchef/tflite/src/Op/L2Pool2D.cpp
new file mode 100644
index 000000000..8db4b02b6
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/L2Pool2D.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "L2Pool2D.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpL2Pool2D::filler(const tflite::Operator *op, TFliteImport *import,
+                              tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpL2Pool2D::build(const tflite::Operator *op, TFliteImport *import,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_Pool2DOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("L2Pool2D");
+
+  auto op_options = operation->mutable_l2pool2d_options();
+
+  op_options->set_padding(as_tflchef_padding(op_params->padding()));
+  op_options->set_stride_h(op_params->stride_h());
+  op_options->set_stride_w(op_params->stride_w());
+  op_options->set_filter_height(op_params->filter_height());
+  op_options->set_filter_width(op_params->filter_width());
+  op_options->set_activation(as_tflchef_activation(op_params->fused_activation_function()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/L2Pool2D.h b/compiler/tflchef/tflite/src/Op/L2Pool2D.h
new file mode 100644
index 000000000..046353440
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/L2Pool2D.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_L2_POOL2D_H__
+#define __TFLITE_OP_L2_POOL2D_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for L2_POOL_2D
+ */
+class TFliteOpL2Pool2D : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_L2_POOL2D_H__
diff --git a/compiler/tflchef/tflite/src/Op/LeakyRelu.cpp b/compiler/tflchef/tflite/src/Op/LeakyRelu.cpp
new file mode 100644
index 000000000..bf9cb2fb3
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LeakyRelu.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LeakyRelu.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLeakyRelu::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLeakyRelu::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_LeakyReluOptions();
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("LeakyRelu");
+
+  auto *op_options = operation->mutable_leaky_relu_options();
+
+  op_options->set_alpha(op_params->alpha());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/LeakyRelu.h b/compiler/tflchef/tflite/src/Op/LeakyRelu.h
new file mode 100644
index 000000000..28e63e0ca
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LeakyRelu.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LEAKY_RELU_H__
+#define __TFLITE_OP_LEAKY_RELU_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LeakyReLU
+ */
+class TFliteOpLeakyRelu : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LEAKY_RELU_H__
diff --git a/compiler/tflchef/tflite/src/Op/Less.cpp b/compiler/tflchef/tflite/src/Op/Less.cpp
new file mode 100644
index 000000000..0360317c7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Less.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Less.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLess::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLess::build(const tflite::Operator *op, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Less");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Less.h b/compiler/tflchef/tflite/src/Op/Less.h
new file mode 100644
index 000000000..1316cb613
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Less.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LESS_H__
+#define __TFLITE_OP_LESS_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Less
+ */
+class TFliteOpLess : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LESS_H__
diff --git a/compiler/tflchef/tflite/src/Op/LessEqual.cpp b/compiler/tflchef/tflite/src/Op/LessEqual.cpp
new file mode 100644
index 000000000..b8c42e80d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LessEqual.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LessEqual.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLessEqual::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLessEqual::build(const tflite::Operator *, TFliteImport *,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("LessEqual");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/LessEqual.h b/compiler/tflchef/tflite/src/Op/LessEqual.h
new file mode 100644
index 000000000..81c710fbc
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LessEqual.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LESSEQUAL_H__
+#define __TFLITE_OP_LESSEQUAL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LessEqual
+ */
+class TFliteOpLessEqual : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LESSEQUAL_H__
diff --git a/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.cpp b/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.cpp
new file mode 100644
index 000000000..8bebd9e90
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LocalResponseNormalization.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLocalResponseNormalization::filler(const tflite::Operator *op, TFliteImport *import,
+                                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *
+TFliteOpLocalResponseNormalization::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_LocalResponseNormalizationOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("LocalResponseNormalization");
+
+  auto op_options = operation->mutable_local_response_normalization_options();
+
+  op_options->set_radius(op_params->radius());
+  op_options->set_bias(op_params->bias());
+  op_options->set_alpha(op_params->alpha());
+  op_options->set_beta(op_params->beta());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.h b/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.h
new file mode 100644
index 000000000..c0eb3f2b1
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LocalResponseNormalization.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LOCAL_RESPONSE_NORMALIZATION_H__
+#define __TFLITE_OP_LOCAL_RESPONSE_NORMALIZATION_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LocalResponseNormalization
+ */
+class TFliteOpLocalResponseNormalization : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LOCAL_RESPONSE_NORMALIZATION_H__
diff --git a/compiler/tflchef/tflite/src/Op/Log.cpp b/compiler/tflchef/tflite/src/Op/Log.cpp
new file mode 100644
index 000000000..a68dc9a31
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Log.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Log.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLog::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLog::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Log");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Log.h b/compiler/tflchef/tflite/src/Op/Log.h
new file mode 100644
index 000000000..9d17e2f81
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Log.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LOG_H__
+#define __TFLITE_OP_LOG_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Log
+ */
+class TFliteOpLog : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LOG_H__
diff --git a/compiler/tflchef/tflite/src/Op/LogSoftmax.cpp b/compiler/tflchef/tflite/src/Op/LogSoftmax.cpp
new file mode 100644
index 000000000..8f0e1a9f9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LogSoftmax.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LogSoftmax.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLogSoftmax::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLogSoftmax::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("LogSoftmax");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/LogSoftmax.h b/compiler/tflchef/tflite/src/Op/LogSoftmax.h
new file mode 100644
index 000000000..efd81f3e9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LogSoftmax.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LOG_SOFTMAX_H__
+#define __TFLITE_OP_LOG_SOFTMAX_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LogSoftmax
+ */
+class TFliteOpLogSoftmax : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LOG_SOFTMAX_H__
diff --git a/compiler/tflchef/tflite/src/Op/LogicalAnd.cpp b/compiler/tflchef/tflite/src/Op/LogicalAnd.cpp
new file mode 100644
index 000000000..2cc486426
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LogicalAnd.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LogicalAnd.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLogicalAnd::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLogicalAnd::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("LogicalAnd");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/LogicalAnd.h b/compiler/tflchef/tflite/src/Op/LogicalAnd.h
new file mode 100644
index 000000000..1f7a964b9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/LogicalAnd.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LOGICALAND_H__
+#define __TFLITE_OP_LOGICALAND_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LogicalAnd
+ */
+class TFliteOpLogicalAnd : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LOGICALAND_H__
diff --git a/compiler/tflchef/tflite/src/Op/Logistic.cpp b/compiler/tflchef/tflite/src/Op/Logistic.cpp
new file mode 100644
index 000000000..18b3b5c00
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Logistic.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Logistic.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpLogistic::filler(const tflite::Operator *, TFliteImport *,
+                              tflchef::ModelRecipe *) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpLogistic::build(const tflite::Operator *, TFliteImport *,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Logistic");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Logistic.h b/compiler/tflchef/tflite/src/Op/Logistic.h
new file mode 100644
index 000000000..a75bf490e
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Logistic.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_LOGISTIC_H__
+#define __TFLITE_OP_LOGISTIC_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for LOGISTIC
+ */
+class TFliteOpLogistic : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_LOGISTIC_H__
diff --git a/compiler/tflchef/tflite/src/Op/MatrixDiag.cpp b/compiler/tflchef/tflite/src/Op/MatrixDiag.cpp
new file mode 100644
index 000000000..ca84c4949
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MatrixDiag.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatrixDiag.h"
+
+namespace tflchef
+{
+
+void TFliteOpMatrixDiag::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpMatrixDiag::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("MatrixDiag");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/MatrixDiag.h b/compiler/tflchef/tflite/src/Op/MatrixDiag.h
new file mode 100644
index 000000000..4074f2c36
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MatrixDiag.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MATRIX_DIAG_H__
+#define __TFLITE_OP_MATRIX_DIAG_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for MatrixDiag
+ */
+class TFliteOpMatrixDiag : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MATRIX_DIAG_H__
diff --git a/compiler/tflchef/tflite/src/Op/MatrixSetDiag.cpp b/compiler/tflchef/tflite/src/Op/MatrixSetDiag.cpp
new file mode 100644
index 000000000..97c7de41f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MatrixSetDiag.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MatrixSetDiag.h"
+
+namespace tflchef
+{
+
+void TFliteOpMatrixSetDiag::filler(const tflite::Operator *, TFliteImport *,
+                                   tflchef::ModelRecipe *) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpMatrixSetDiag::build(const tflite::Operator *, TFliteImport *,
+                                                 tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("MatrixSetDiag");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/MatrixSetDiag.h b/compiler/tflchef/tflite/src/Op/MatrixSetDiag.h
new file mode 100644
index 000000000..0e7ec7f32
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MatrixSetDiag.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MATRIX_SET_DIAG_H__
+#define __TFLITE_OP_MATRIX_SET_DIAG_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for MatrixSetDiag
+ */
+class TFliteOpMatrixSetDiag : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MATRIX_SET_DIAG_H__
diff --git a/compiler/tflchef/tflite/src/Op/Maximum.cpp b/compiler/tflchef/tflite/src/Op/Maximum.cpp
new file mode 100644
index 000000000..fb977b6ed
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Maximum.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Maximum.h"
+
+namespace tflchef
+{
+
+void TFliteOpMaximum::filler(const tflite::Operator *op, TFliteImport *import,
+                             tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpMaximum::build(const tflite::Operator *op, TFliteImport *import,
+                                           tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Maximum");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Maximum.h b/compiler/tflchef/tflite/src/Op/Maximum.h
new file mode 100644
index 000000000..acafec343
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Maximum.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MAXIMUM_H__
+#define __TFLITE_OP_MAXIMUM_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for maximum
+ */
+class TFliteOpMaximum : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MAXIMUM_H__
diff --git a/compiler/tflchef/tflite/src/Op/Minimum.cpp b/compiler/tflchef/tflite/src/Op/Minimum.cpp
new file mode 100644
index 000000000..2bb50cb89
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Minimum.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Minimum.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpMinimum::filler(const tflite::Operator *op, TFliteImport *import,
+                             tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpMinimum::build(const tflite::Operator *op, TFliteImport *import,
+                                           tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Minimum");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Minimum.h b/compiler/tflchef/tflite/src/Op/Minimum.h
new file mode 100644
index 000000000..5db5b7940
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Minimum.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MINIMUM_H__
+#define __TFLITE_OP_MINIMUM_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for minimum
+ */
+class TFliteOpMinimum : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MINIMUM_H__
diff --git a/compiler/tflchef/tflite/src/Op/MirrorPad.cpp b/compiler/tflchef/tflite/src/Op/MirrorPad.cpp
new file mode 100644
index 000000000..c688552ee
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MirrorPad.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MirrorPad.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpMirrorPad::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpMirrorPad::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("MirrorPad");
+
+  auto op_options = operation->mutable_mirrorpad_options();
+
+  auto op_params = op->builtin_options_as_MirrorPadOptions();
+  assert(op_params != nullptr);
+
+  op_options->set_mode(as_tflchef_mirrorpadmode(op_params->mode()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/MirrorPad.h b/compiler/tflchef/tflite/src/Op/MirrorPad.h
new file mode 100644
index 000000000..c9acdd498
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/MirrorPad.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MIRROR_PAD_H__
+#define __TFLITE_OP_MIRROR_PAD_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for MIRROR_PAD
+ */
+class TFliteOpMirrorPad : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MIRROR_PAD_H__
diff --git a/compiler/tflchef/tflite/src/Op/Mul.cpp b/compiler/tflchef/tflite/src/Op/Mul.cpp
new file mode 100644
index 000000000..9faa4acaf
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Mul.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Mul.h"
+
+#include "Convert.h"
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpMul::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // Mul may have constant input
+
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+  assert(inputs.size() == 2);
+
+  fill_tensor_to_import(inputs[0], import);
+  fill_tensor_to_import(inputs[1], import);
+}
+
+tflchef::Operation *TFliteOpMul::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Mul");
+
+  auto op_params = op->builtin_options_as_MulOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_mul_options();
+  op_options->set_activation(as_tflchef_activation(op_params->fused_activation_function()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Mul.h b/compiler/tflchef/tflite/src/Op/Mul.h
new file mode 100644
index 000000000..fd009d2fd
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Mul.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_MUL_H__
+#define __TFLITE_OP_MUL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for MUL
+ */
+class TFliteOpMul : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_MUL_H__
diff --git a/compiler/tflchef/tflite/src/Op/Neg.cpp b/compiler/tflchef/tflite/src/Op/Neg.cpp
new file mode 100644
index 000000000..c691390a3
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Neg.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Neg.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpNeg::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpNeg::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Neg");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Neg.h b/compiler/tflchef/tflite/src/Op/Neg.h
new file mode 100644
index 000000000..c77ab7e84
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Neg.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_NEG_H__
+#define __TFLITE_OP_NEG_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for abs
+ */
+class TFliteOpNeg : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_NEG_H__
diff --git a/compiler/tflchef/tflite/src/Op/NotEqual.cpp b/compiler/tflchef/tflite/src/Op/NotEqual.cpp
new file mode 100644
index 000000000..c2275db06
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/NotEqual.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "NotEqual.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpNotEqual::filler(const tflite::Operator *op, TFliteImport *import,
+                              tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpNotEqual::build(const tflite::Operator *op, TFliteImport *import,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("NotEqual");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/NotEqual.h b/compiler/tflchef/tflite/src/Op/NotEqual.h
new file mode 100644
index 000000000..b1febdcc5
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/NotEqual.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_NOTEQUAL_H__
+#define __TFLITE_OP_NOTEQUAL_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Not Equal
+ */
+class TFliteOpNotEqual : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_NOTEQUAL_H__
diff --git a/compiler/tflchef/tflite/src/Op/OneHot.cpp b/compiler/tflchef/tflite/src/Op/OneHot.cpp
new file mode 100644
index 000000000..f26ed3e7f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/OneHot.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "OneHot.h"
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpOneHot::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // only depth(second input) has constant on recipe cause depth value is used in shape inference.
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[1], vec);
+  }
+
+  // on/off can be dtype of input/output. let's support INT32/FLOAT32 for now
+  for (int32_t index = 2; index <= 3; ++index)
+  {
+    const tflite::Tensor *tensor = import->tensors()->Get(inputs[index]);
+    const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+    if (buffer && buffer->data())
+    {
+      switch (tensor->type())
+      {
+        case tflite::TensorType::TensorType_INT32:
+        {
+          auto vec = extract_buffer<int32_t>(buffer);
+          import->set_tensor_filler(inputs[index], vec);
+          break;
+        }
+
+        case tflite::TensorType::TensorType_FLOAT32:
+        {
+          auto vec = extract_buffer<float>(buffer);
+          import->set_tensor_filler(inputs[index], vec);
+          break;
+        }
+
+        default:
+          assert(false);
+          break;
+      }
+    }
+  }
+}
+
+tflchef::Operation *TFliteOpOneHot::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_OneHotOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("OneHot");
+
+  auto op_options = operation->mutable_onehot_options();
+
+  op_options->set_axis(op_params->axis());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/OneHot.h b/compiler/tflchef/tflite/src/Op/OneHot.h
new file mode 100644
index 000000000..50bbed095
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/OneHot.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ONEHOT_H__
+#define __TFLITE_OP_ONEHOT_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for OneHot
+ */
+class TFliteOpOneHot : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ONEHOT_H__
diff --git a/compiler/tflchef/tflite/src/Op/PRelu.cpp b/compiler/tflchef/tflite/src/Op/PRelu.cpp
new file mode 100644
index 000000000..8a5e83a84
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/PRelu.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "PRelu.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpPRelu::filler(const tflite::Operator *op, TFliteImport *import,
+                           tflchef::ModelRecipe *model_recipe) const
+{
+}
+
+tflchef::Operation *TFliteOpPRelu::build(const tflite::Operator *op, TFliteImport *import,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("PRelu");
+
+  // PReluOptions are empty
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/PRelu.h b/compiler/tflchef/tflite/src/Op/PRelu.h
new file mode 100644
index 000000000..b35c6e7ce
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/PRelu.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_PRELU_H__
+#define __TFLITE_OP_PRELU_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for PRelu
+ */
+class TFliteOpPRelu : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_PRELU_H__
diff --git a/compiler/tflchef/tflite/src/Op/Pow.cpp b/compiler/tflchef/tflite/src/Op/Pow.cpp
new file mode 100644
index 000000000..fe8e8ac0f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Pow.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Pow.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpPow::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+}
+
+tflchef::Operation *TFliteOpPow::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("Pow");
+
+  // PowOptions are empty
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Pow.h b/compiler/tflchef/tflite/src/Op/Pow.h
new file mode 100644
index 000000000..20e847377
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Pow.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_POW_H__
+#define __TFLITE_OP_POW_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Pow
+ */
+class TFliteOpPow : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_POW_H__
diff --git a/compiler/tflchef/tflite/src/Op/Range.cpp b/compiler/tflchef/tflite/src/Op/Range.cpp
new file mode 100644
index 000000000..2958b9c41
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Range.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Range.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpRange::filler(const tflite::Operator *op, TFliteImport *import,
+                           tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for all inputs
+  const auto &inputs = *op->inputs();
+
+  for (int index = 0; index < 3; ++index)
+  {
+    const tflite::Tensor *tensor = import->tensors()->Get(inputs[index]);
+    const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+    if (tensor->type() == tflite::TensorType::TensorType_INT32)
+    {
+      auto vec = extract_buffer<int32_t>(buffer);
+      import->set_tensor_filler(inputs[index], vec);
+    }
+    else if (tensor->type() == tflite::TensorType::TensorType_FLOAT32)
+    {
+      auto vec = extract_buffer<float>(buffer);
+      import->set_tensor_filler(inputs[index], vec);
+    }
+    else
+    {
+      assert(false && "Invalid tensor type");
+    }
+  }
+}
+
+tflchef::Operation *TFliteOpRange::build(const tflite::Operator *op, TFliteImport *import,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Range");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Range.h b/compiler/tflchef/tflite/src/Op/Range.h
new file mode 100644
index 000000000..ad10dc58b
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Range.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_RANGE_H__
+#define __TFLITE_OP_RANGE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for abs
+ */
+class TFliteOpRange : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_RANGE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Rank.cpp b/compiler/tflchef/tflite/src/Op/Rank.cpp
new file mode 100644
index 000000000..184c8e482
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Rank.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Rank.h"
+
+namespace tflchef
+{
+
+void TFliteOpRank::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpRank::build(const tflite::Operator *, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Rank");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Rank.h b/compiler/tflchef/tflite/src/Op/Rank.h
new file mode 100644
index 000000000..003d9d310
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Rank.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_RANK_H__
+#define __TFLITE_OP_RANK_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for rank
+ */
+class TFliteOpRank : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_RANK_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReLUN1To1.cpp b/compiler/tflchef/tflite/src/Op/ReLUN1To1.cpp
new file mode 100644
index 000000000..4cc8dbd2b
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReLUN1To1.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReLUN1To1.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpReLUN1To1::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpReLUN1To1::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ReLUN1To1");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReLUN1To1.h b/compiler/tflchef/tflite/src/Op/ReLUN1To1.h
new file mode 100644
index 000000000..0767006af
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReLUN1To1.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_RELU_N1_TO_1_H__
+#define __TFLITE_OP_RELU_N1_TO_1_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for RELU_N1_TO_1
+ */
+class TFliteOpReLUN1To1 : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_RELU_N1_TO_1_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReduceAny.cpp b/compiler/tflchef/tflite/src/Op/ReduceAny.cpp
new file mode 100644
index 000000000..e0cc503c4
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceAny.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceAny.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpReduceAny::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpReduceAny::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("ReduceAny");
+
+  auto op_params = op->builtin_options_as_ReducerOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_reduce_any_options();
+  op_options->set_keep_dims(op_params->keep_dims());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReduceAny.h b/compiler/tflchef/tflite/src/Op/ReduceAny.h
new file mode 100644
index 000000000..dd5e361d5
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceAny.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REDUCE_ANY_H__
+#define __TFLITE_OP_REDUCE_ANY_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for REDUCE_ANY
+ */
+class TFliteOpReduceAny : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REDUCE_ANY_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReduceMax.cpp b/compiler/tflchef/tflite/src/Op/ReduceMax.cpp
new file mode 100644
index 000000000..499f58566
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceMax.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceMax.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpReduceMax::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpReduceMax::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ReducerOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ReduceMax");
+
+  auto op_options = operation->mutable_reduce_max_options();
+
+  op_options->set_keep_dims(op_params->keep_dims());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReduceMax.h b/compiler/tflchef/tflite/src/Op/ReduceMax.h
new file mode 100644
index 000000000..8e65cf47c
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceMax.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REDUCEMAX_H__
+#define __TFLITE_OP_REDUCEMAX_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Reduce Max
+ */
+class TFliteOpReduceMax : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REDUCEMAX_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReduceMin.cpp b/compiler/tflchef/tflite/src/Op/ReduceMin.cpp
new file mode 100644
index 000000000..09e2e134c
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceMin.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceMin.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpReduceMin::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpReduceMin::build(const tflite::Operator *op, TFliteImport *import,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ReducerOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ReduceMin");
+
+  auto op_options = operation->mutable_reduce_min_options();
+
+  op_options->set_keep_dims(op_params->keep_dims());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReduceMin.h b/compiler/tflchef/tflite/src/Op/ReduceMin.h
new file mode 100644
index 000000000..88cba6fe7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceMin.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REDUCEMIN_H__
+#define __TFLITE_OP_REDUCEMIN_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Reduce Min
+ */
+class TFliteOpReduceMin : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REDUCEMIN_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReduceProd.cpp b/compiler/tflchef/tflite/src/Op/ReduceProd.cpp
new file mode 100644
index 000000000..e2d98970d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceProd.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReduceProd.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpReduceProd::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpReduceProd::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("ReduceProd");
+
+  auto op_params = op->builtin_options_as_ReducerOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_reduce_prod_options();
+  op_options->set_keep_dims(op_params->keep_dims());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReduceProd.h b/compiler/tflchef/tflite/src/Op/ReduceProd.h
new file mode 100644
index 000000000..e7766840a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReduceProd.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REDUCE_PROD_H__
+#define __TFLITE_OP_REDUCE_PROD_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for REDUCE_PROD
+ */
+class TFliteOpReduceProd : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REDUCE_PROD_H__
diff --git a/compiler/tflchef/tflite/src/Op/Reshape.cpp b/compiler/tflchef/tflite/src/Op/Reshape.cpp
index 663ab3ec3..0094d5df5 100644
--- a/compiler/tflchef/tflite/src/Op/Reshape.cpp
+++ b/compiler/tflchef/tflite/src/Op/Reshape.cpp
@@ -17,6 +17,7 @@
 #include "Reshape.h"
 
 #include "Convert.h"
+#include "FillerHelper.h"
 
 namespace tflchef
 {
@@ -27,33 +28,29 @@ void TFliteOpReshape::filler(const tflite::Operator *op, TFliteImport *import,
   const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
 
   bool hasShape = (inputs.size() == 2);
-  assert(inputs.size() == 1 || hasShape);
-
   if (hasShape)
   {
-    auto op_params = op->builtin_options_as_ReshapeOptions();
-    std::vector<int32_t> new_shape = as_index_vector(op_params->new_shape());
-    import->set_tensor_filler(inputs.at(1), new_shape);
+    fill_tensor_to_import(inputs[1], import);
   }
 }
 
 tflchef::Operation *TFliteOpReshape::build(const tflite::Operator *op, TFliteImport *import,
                                            tflchef::ModelRecipe *model_recipe) const
 {
-  auto op_params = op->builtin_options_as_ReshapeOptions();
-  assert(op_params != nullptr);
-
   auto operation = model_recipe->add_operation();
 
   operation->set_type("Reshape");
 
-  auto op_options = operation->mutable_reshape_options();
-
-  std::vector<int32_t> new_shape = as_index_vector(op_params->new_shape());
-
-  for (auto shape : new_shape)
+  auto op_params = op->builtin_options_as_ReshapeOptions();
+  if (op_params != nullptr)
   {
-    op_options->add_new_shape(shape);
+    auto op_options = operation->mutable_reshape_options();
+
+    std::vector<int32_t> new_shape = as_index_vector(op_params->new_shape());
+    for (auto shape : new_shape)
+    {
+      op_options->add_new_shape(shape);
+    }
   }
 
   return operation;
diff --git a/compiler/tflchef/tflite/src/Op/ResizeBilinear.cpp b/compiler/tflchef/tflite/src/Op/ResizeBilinear.cpp
new file mode 100644
index 000000000..0f6db1fcb
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ResizeBilinear.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ResizeBilinear.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpResizeBilinear::filler(const tflite::Operator *op, TFliteImport *import,
+                                    tflchef::ModelRecipe *model_recipe) const
+{
+  // size buffer has filler
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[1], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpResizeBilinear::build(const tflite::Operator *op, TFliteImport *import,
+                                                  tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ResizeBilinearOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ResizeBilinear");
+
+  auto op_options = operation->mutable_resize_bilinear_options();
+
+  op_options->set_align_corners(op_params->align_corners());
+  op_options->set_half_pixel_centers(op_params->half_pixel_centers());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ResizeBilinear.h b/compiler/tflchef/tflite/src/Op/ResizeBilinear.h
new file mode 100644
index 000000000..98c49c534
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ResizeBilinear.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_RESIZE_BILINEAR_H__
+#define __TFLITE_OP_RESIZE_BILINEAR_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ResizeBilinear
+ */
+class TFliteOpResizeBilinear : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_RESIZE_BILINEAR_H__
diff --git a/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.cpp b/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.cpp
new file mode 100644
index 000000000..f3dd8fed0
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ResizeNearestNeighbor.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpResizeNearestNeighbor::filler(const tflite::Operator *op, TFliteImport *import,
+                                           tflchef::ModelRecipe *model_recipe) const
+{
+  // size buffer has filler
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[1], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpResizeNearestNeighbor::build(const tflite::Operator *op,
+                                                         TFliteImport *import,
+                                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ResizeNearestNeighborOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ResizeNearestNeighbor");
+
+  auto op_options = operation->mutable_resize_nearest_neighbor_options();
+
+  op_options->set_align_corners(op_params->align_corners());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.h b/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.h
new file mode 100644
index 000000000..5090bb938
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ResizeNearestNeighbor.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_RESIZE_NEAREST_NEIGHBOR_H__
+#define __TFLITE_OP_RESIZE_NEAREST_NEIGHBOR_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ResizeNearestNeighbor
+ */
+class TFliteOpResizeNearestNeighbor : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_RESIZE_NEAREST_NEIGHBOR_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReverseSequence.cpp b/compiler/tflchef/tflite/src/Op/ReverseSequence.cpp
new file mode 100644
index 000000000..6ef6c2326
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReverseSequence.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReverseSequence.h"
+
+#include "Convert.h"
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpReverseSequence::filler(const tflite::Operator *op, TFliteImport *import,
+                                     tflchef::ModelRecipe *) const
+{
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+  assert(inputs.size() == 2);
+
+  fill_tensor_to_import(inputs[1], import);
+}
+
+tflchef::Operation *TFliteOpReverseSequence::build(const tflite::Operator *op, TFliteImport *,
+                                                   tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ReverseSequence");
+
+  auto op_params = op->builtin_options_as_ReverseSequenceOptions();
+
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_reverse_sequence_options();
+
+  op_options->set_seq_dim(op_params->seq_dim());
+  op_options->set_batch_dim(op_params->batch_dim());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReverseSequence.h b/compiler/tflchef/tflite/src/Op/ReverseSequence.h
new file mode 100644
index 000000000..8c8c811e4
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReverseSequence.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REVERSE_SEQUENCE_H__
+#define __TFLITE_OP_REVERSE_SEQUENCE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ReverseSequence
+ */
+class TFliteOpReverseSequence : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REVERSE_SEQUENCE_H__
diff --git a/compiler/tflchef/tflite/src/Op/ReverseV2.cpp b/compiler/tflchef/tflite/src/Op/ReverseV2.cpp
new file mode 100644
index 000000000..c59d97574
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReverseV2.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReverseV2.h"
+
+#include "Convert.h"
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpReverseV2::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *) const
+{
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+  assert(inputs.size() == 2);
+
+  fill_tensor_to_import(inputs[1], import);
+}
+
+tflchef::Operation *TFliteOpReverseV2::build(const tflite::Operator *, TFliteImport *,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ReverseV2");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ReverseV2.h b/compiler/tflchef/tflite/src/Op/ReverseV2.h
new file mode 100644
index 000000000..6a8a75e6b
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ReverseV2.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_REVERSEV2_H__
+#define __TFLITE_OP_REVERSEV2_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ReverseV2
+ */
+class TFliteOpReverseV2 : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_REVERSEV2_H__
diff --git a/compiler/tflchef/tflite/src/Op/Round.cpp b/compiler/tflchef/tflite/src/Op/Round.cpp
new file mode 100644
index 000000000..c3f6bf6c4
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Round.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Round.h"
+
+namespace tflchef
+{
+
+void TFliteOpRound::filler(const tflite::Operator *, TFliteImport *, tflchef::ModelRecipe *) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpRound::build(const tflite::Operator *, TFliteImport *,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Round");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Round.h b/compiler/tflchef/tflite/src/Op/Round.h
new file mode 100644
index 000000000..df0da3fa1
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Round.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ROUND_H__
+#define __TFLITE_OP_ROUND_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Round
+ */
+class TFliteOpRound : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ROUND_H__
diff --git a/compiler/tflchef/tflite/src/Op/ScatterNd.cpp b/compiler/tflchef/tflite/src/Op/ScatterNd.cpp
new file mode 100644
index 000000000..548a09a67
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ScatterNd.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ScatterNd.h"
+
+#include "Convert.h"
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpScatterNd::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // Filler for indices and shape
+  fill_tensor_to_import(0, import);
+  fill_tensor_to_import(2, import);
+}
+
+tflchef::Operation *TFliteOpScatterNd::build(const tflite::Operator *, TFliteImport *,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("ScatterNd");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ScatterNd.h b/compiler/tflchef/tflite/src/Op/ScatterNd.h
new file mode 100644
index 000000000..76362d775
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ScatterNd.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SCATTER_ND_H__
+#define __TFLITE_OP_SCATTER_ND_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ScatterNd
+ */
+class TFliteOpScatterNd : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SCATTER_ND_H__
diff --git a/compiler/tflchef/tflite/src/Op/SegmentSum.cpp b/compiler/tflchef/tflite/src/Op/SegmentSum.cpp
new file mode 100644
index 000000000..a975ca4b3
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SegmentSum.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SegmentSum.h"
+
+#include "FillerHelper.h"
+
+namespace tflchef
+{
+
+void TFliteOpSegmentSum::filler(const tflite::Operator *op, TFliteImport *import,
+                                tflchef::ModelRecipe *model_recipe) const
+{
+  // Filler for indices and shape
+  fill_tensor_to_import(1, import);
+}
+
+tflchef::Operation *TFliteOpSegmentSum::build(const tflite::Operator *op, TFliteImport *import,
+                                              tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SegmentSum");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SegmentSum.h b/compiler/tflchef/tflite/src/Op/SegmentSum.h
new file mode 100644
index 000000000..d20e63bd7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SegmentSum.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SEGMENT_SUM_H__
+#define __TFLITE_OP_SEGMENT_SUM_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SEGMENT_SUM
+ */
+class TFliteOpSegmentSum : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SEGMENT_SUM_H__
diff --git a/compiler/tflchef/tflite/src/Op/Select.cpp b/compiler/tflchef/tflite/src/Op/Select.cpp
new file mode 100644
index 000000000..741ffb8f6
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Select.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Select.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSelect::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSelect::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Select");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Select.h b/compiler/tflchef/tflite/src/Op/Select.h
new file mode 100644
index 000000000..bf8e57d78
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Select.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SELECT_H__
+#define __TFLITE_OP_SELECT_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SELECT
+ */
+class TFliteOpSelect : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SELECT_H__
diff --git a/compiler/tflchef/tflite/src/Op/SelectV2.cpp b/compiler/tflchef/tflite/src/Op/SelectV2.cpp
new file mode 100644
index 000000000..0ddabb4be
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SelectV2.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SelectV2.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSelectV2::filler(const tflite::Operator *op, TFliteImport *import,
+                              tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSelectV2::build(const tflite::Operator *op, TFliteImport *import,
+                                            tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SelectV2");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SelectV2.h b/compiler/tflchef/tflite/src/Op/SelectV2.h
new file mode 100644
index 000000000..ff03341d7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SelectV2.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SELECT_V2_H__
+#define __TFLITE_OP_SELECT_V2_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SELECT
+ */
+class TFliteOpSelectV2 : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SELECT_V2_H__
diff --git a/compiler/tflchef/tflite/src/Op/Shape.cpp b/compiler/tflchef/tflite/src/Op/Shape.cpp
new file mode 100644
index 000000000..d6e490d63
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Shape.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Shape.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpShape::filler(const tflite::Operator *op, TFliteImport *import,
+                           tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpShape::build(const tflite::Operator *op, TFliteImport *import,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("Shape");
+
+  auto op_params = op->builtin_options_as_ShapeOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_shape_options();
+  op_options->set_out_type(as_tflchef_type(op_params->out_type()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Shape.h b/compiler/tflchef/tflite/src/Op/Shape.h
new file mode 100644
index 000000000..ebe1befb3
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Shape.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SHAPE_H__
+#define __TFLITE_OP_SHAPE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SHAPE
+ */
+class TFliteOpShape : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SHAPE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Sin.cpp b/compiler/tflchef/tflite/src/Op/Sin.cpp
new file mode 100644
index 000000000..8c063f424
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Sin.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Sin.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSin::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSin::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Sin");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Sin.h b/compiler/tflchef/tflite/src/Op/Sin.h
new file mode 100644
index 000000000..51eabceb5
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Sin.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SIN_H__
+#define __TFLITE_OP_SIN_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Sin
+ */
+class TFliteOpSin : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SIN_H__
diff --git a/compiler/tflchef/tflite/src/Op/Slice.cpp b/compiler/tflchef/tflite/src/Op/Slice.cpp
new file mode 100644
index 000000000..f0c44da2d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Slice.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Slice.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSlice::filler(const tflite::Operator *op, TFliteImport *import,
+                           tflchef::ModelRecipe *model_recipe) const
+{
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+
+  // for begin and size
+  for (int32_t index = 1; index <= 2; ++index)
+  {
+    const tflite::Tensor *tensor = import->tensors()->Get(inputs[index]);
+    assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+    const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[index], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpSlice::build(const tflite::Operator *op, TFliteImport *import,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Slice");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Slice.h b/compiler/tflchef/tflite/src/Op/Slice.h
new file mode 100644
index 000000000..6ca6724d3
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Slice.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SLICE_H__
+#define __TFLITE_OP_SLICE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SLICE
+ */
+class TFliteOpSlice : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SLICE_H__
diff --git a/compiler/tflchef/tflite/src/Op/SpaceToBatchND.cpp b/compiler/tflchef/tflite/src/Op/SpaceToBatchND.cpp
new file mode 100644
index 000000000..9de0775a9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SpaceToBatchND.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SpaceToBatchND.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSpaceToBatchND::filler(const tflite::Operator *op, TFliteImport *import,
+                                    tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second, third input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+
+  tensor = import->tensors()->Get(inputs[2]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  buffer = import->buffers()->Get(tensor->buffer());
+  vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[2], vec);
+}
+
+tflchef::Operation *TFliteOpSpaceToBatchND::build(const tflite::Operator *op, TFliteImport *import,
+                                                  tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SpaceToBatchND");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SpaceToBatchND.h b/compiler/tflchef/tflite/src/Op/SpaceToBatchND.h
new file mode 100644
index 000000000..9d7bc44e8
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SpaceToBatchND.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SPACETOBATCHND_H__
+#define __TFLITE_OP_SPACETOBATCHND_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SpaceToBatchND
+ */
+class TFliteOpSpaceToBatchND : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SPACETOBATCHND_H__
diff --git a/compiler/tflchef/tflite/src/Op/SpaceToDepth.cpp b/compiler/tflchef/tflite/src/Op/SpaceToDepth.cpp
new file mode 100644
index 000000000..e5718b515
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SpaceToDepth.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SpaceToDepth.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSpaceToDepth::filler(const tflite::Operator *op, TFliteImport *import,
+                                  tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSpaceToDepth::build(const tflite::Operator *op, TFliteImport *import,
+                                                tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SpaceToDepth");
+
+  auto op_params = op->builtin_options_as_SpaceToDepthOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_space_to_depth_options();
+
+  op_options->set_block_size(op_params->block_size());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SpaceToDepth.h b/compiler/tflchef/tflite/src/Op/SpaceToDepth.h
new file mode 100644
index 000000000..784ad940a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SpaceToDepth.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SPACETODEPTH_H__
+#define __TFLITE_OP_SPACETODEPTH_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SpaceToDepth
+ */
+class TFliteOpSpaceToDepth : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SPACETODEPTH_H__
diff --git a/compiler/tflchef/tflite/src/Op/SparseToDense.cpp b/compiler/tflchef/tflite/src/Op/SparseToDense.cpp
new file mode 100644
index 000000000..9e4f0a067
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SparseToDense.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SparseToDense.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSparseToDense::filler(const tflite::Operator *op, TFliteImport *import,
+                                   tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for Shape
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *output_shape_tensor = import->tensors()->Get(inputs[1]);
+  assert(output_shape_tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(output_shape_tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpSparseToDense::build(const tflite::Operator *op, TFliteImport *import,
+                                                 tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_SparseToDenseOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SparseToDense");
+
+  auto op_options = operation->mutable_sparse_to_dense_options();
+
+  op_options->set_validate_indices(op_params->validate_indices());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SparseToDense.h b/compiler/tflchef/tflite/src/Op/SparseToDense.h
new file mode 100644
index 000000000..5ffe4789d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SparseToDense.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SPARSETODENSE_H__
+#define __TFLITE_OP_SPARSETODENSE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SparseToDense
+ */
+class TFliteOpSparseToDense : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SPARSETODENSE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Split.cpp b/compiler/tflchef/tflite/src/Op/Split.cpp
new file mode 100644
index 000000000..49f9aa2c6
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Split.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Split.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSplit::filler(const tflite::Operator *op, TFliteImport *import,
+                           tflchef::ModelRecipe *model_recipe) const
+{
+  const auto &inputs = *op->inputs();
+
+  // for input split_dim
+  // NOTE unlike other Ops, Split input 0 is split_dim
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[0]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[0], vec);
+}
+
+tflchef::Operation *TFliteOpSplit::build(const tflite::Operator *op, TFliteImport *import,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Split");
+
+  auto op_options = operation->mutable_split_options();
+
+  auto op_params = op->builtin_options_as_SplitOptions();
+  assert(op_params != nullptr);
+
+  op_options->set_num_splits(op_params->num_splits());
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Split.h b/compiler/tflchef/tflite/src/Op/Split.h
new file mode 100644
index 000000000..af247a1b9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Split.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SPLIT_H__
+#define __TFLITE_OP_SPLIT_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SPLIT
+ */
+class TFliteOpSplit : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SPLIT_H__
diff --git a/compiler/tflchef/tflite/src/Op/SplitV.cpp b/compiler/tflchef/tflite/src/Op/SplitV.cpp
new file mode 100644
index 000000000..18035e6f4
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SplitV.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SplitV.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSplitV::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  const auto &inputs = *op->inputs();
+
+  // for input "size_splits" and "split_dim"
+  for (int32_t idx = 1; idx <= 2; idx++)
+  {
+    const tflite::Tensor *tensor = import->tensors()->Get(inputs[idx]);
+    assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+    const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[idx], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpSplitV::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SplitV");
+
+  auto op_options = operation->mutable_split_v_options();
+
+  auto op_params = op->builtin_options_as_SplitVOptions();
+  assert(op_params != nullptr);
+
+  op_options->set_num_splits(op_params->num_splits());
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SplitV.h b/compiler/tflchef/tflite/src/Op/SplitV.h
new file mode 100644
index 000000000..3f715b5f9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SplitV.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SPLIT_V_H__
+#define __TFLITE_OP_SPLIT_V_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SPLIT_V
+ */
+class TFliteOpSplitV : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SPLIT_V_H__
diff --git a/compiler/tflchef/tflite/src/Op/Square.cpp b/compiler/tflchef/tflite/src/Op/Square.cpp
new file mode 100644
index 000000000..d3803284a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Square.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Square.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSquare::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSquare::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Square");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Square.h b/compiler/tflchef/tflite/src/Op/Square.h
new file mode 100644
index 000000000..9c008fe52
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Square.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SQUARE_H__
+#define __TFLITE_OP_SQUARE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Square
+ */
+class TFliteOpSquare : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SQUARE_H__
diff --git a/compiler/tflchef/tflite/src/Op/SquaredDifference.cpp b/compiler/tflchef/tflite/src/Op/SquaredDifference.cpp
new file mode 100644
index 000000000..1ee536e76
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SquaredDifference.cpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SquaredDifference.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSquaredDifference::filler(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSquaredDifference::build(const tflite::Operator *op,
+                                                     TFliteImport *import,
+                                                     tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("SquaredDifference");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/SquaredDifference.h b/compiler/tflchef/tflite/src/Op/SquaredDifference.h
new file mode 100644
index 000000000..58c2ed460
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/SquaredDifference.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SQUAREDDIFFERENCE_H__
+#define __TFLITE_OP_SQUAREDDIFFERENCE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for SquaredDifference
+ */
+class TFliteOpSquaredDifference : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SQUAREDDIFFERENCE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Squeeze.cpp b/compiler/tflchef/tflite/src/Op/Squeeze.cpp
new file mode 100644
index 000000000..7983fc62a
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Squeeze.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Squeeze.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSqueeze::filler(const tflite::Operator *op, TFliteImport *import,
+                             tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpSqueeze::build(const tflite::Operator *op, TFliteImport *import,
+                                           tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_SqueezeOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Squeeze");
+
+  auto op_options = operation->mutable_squeeze_options();
+
+  std::vector<int32_t> squeeze_dims = as_index_vector(op_params->squeeze_dims());
+
+  for (auto dim : squeeze_dims)
+  {
+    op_options->add_squeeze_dim(dim);
+  }
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Squeeze.h b/compiler/tflchef/tflite/src/Op/Squeeze.h
new file mode 100644
index 000000000..b6c89f73d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Squeeze.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SQUEEZE_H__
+#define __TFLITE_OP_SQUEEZE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Squeeze
+ */
+class TFliteOpSqueeze : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SQUEEZE_H__
diff --git a/compiler/tflchef/tflite/src/Op/StridedSlice.cpp b/compiler/tflchef/tflite/src/Op/StridedSlice.cpp
new file mode 100644
index 000000000..c770236c7
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/StridedSlice.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "StridedSlice.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpStridedSlice::filler(const tflite::Operator *op, TFliteImport *import,
+                                  tflchef::ModelRecipe *model_recipe) const
+{
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+
+  // for begin, end and strides
+  for (int32_t index = 1; index <= 3; ++index)
+  {
+    const tflite::Tensor *tensor = import->tensors()->Get(inputs[index]);
+    assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+    const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[index], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpStridedSlice::build(const tflite::Operator *op, TFliteImport *import,
+                                                tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_StridedSliceOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("StridedSlice");
+
+  auto op_options = operation->mutable_strided_slice_options();
+
+  op_options->set_begin_mask(op_params->begin_mask());
+  op_options->set_end_mask(op_params->end_mask());
+  op_options->set_ellipsis_mask(op_params->ellipsis_mask());
+  op_options->set_new_axis_mask(op_params->new_axis_mask());
+  op_options->set_shrink_axis_mask(op_params->shrink_axis_mask());
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/StridedSlice.h b/compiler/tflchef/tflite/src/Op/StridedSlice.h
new file mode 100644
index 000000000..98054b9b9
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/StridedSlice.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_STRIDEDSLICE_H__
+#define __TFLITE_OP_STRIDEDSLICE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for StridedSlice
+ */
+class TFliteOpStridedSlice : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_STRIDEDSLICE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Sub.cpp b/compiler/tflchef/tflite/src/Op/Sub.cpp
index db77fddf7..0a08bbfdf 100644
--- a/compiler/tflchef/tflite/src/Op/Sub.cpp
+++ b/compiler/tflchef/tflite/src/Op/Sub.cpp
@@ -17,6 +17,7 @@
 #include "Sub.h"
 
 #include "Convert.h"
+#include "FillerHelper.h"
 
 namespace tflchef
 {
@@ -24,7 +25,13 @@ namespace tflchef
 void TFliteOpSub::filler(const tflite::Operator *op, TFliteImport *import,
                          tflchef::ModelRecipe *model_recipe) const
 {
-  // Nothing to do with filler
+  // Sub may have constant input
+
+  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
+  assert(inputs.size() == 2);
+
+  fill_tensor_to_import(inputs[0], import);
+  fill_tensor_to_import(inputs[1], import);
 }
 
 tflchef::Operation *TFliteOpSub::build(const tflite::Operator *op, TFliteImport *import,
diff --git a/compiler/tflchef/tflite/src/Op/Sum.cpp b/compiler/tflchef/tflite/src/Op/Sum.cpp
new file mode 100644
index 000000000..9f3133e85
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Sum.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Sum.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpSum::filler(const tflite::Operator *op, TFliteImport *import,
+                         tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpSum::build(const tflite::Operator *op, TFliteImport *import,
+                                       tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_ReducerOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Sum");
+
+  auto op_options = operation->mutable_sum_options();
+
+  op_options->set_keep_dims(op_params->keep_dims());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Sum.h b/compiler/tflchef/tflite/src/Op/Sum.h
new file mode 100644
index 000000000..38eeb080d
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Sum.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_SUM_H__
+#define __TFLITE_OP_SUM_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for sum
+ */
+class TFliteOpSum : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_SUM_H__
diff --git a/compiler/tflchef/tflite/src/Op/Tile.cpp b/compiler/tflchef/tflite/src/Op/Tile.cpp
new file mode 100644
index 000000000..14e65131c
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Tile.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Tile.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpTile::filler(const tflite::Operator *op, TFliteImport *import,
+                          tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32 ||
+         tensor->type() == tflite::TensorType::TensorType_INT64);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpTile::build(const tflite::Operator *op, TFliteImport *import,
+                                        tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Tile");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Tile.h b/compiler/tflchef/tflite/src/Op/Tile.h
new file mode 100644
index 000000000..640f52a1f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Tile.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_TILE_H__
+#define __TFLITE_OP_TILE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Tile
+ */
+class TFliteOpTile : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_TILE_H__
diff --git a/compiler/tflchef/tflite/src/Op/TopKV2.cpp b/compiler/tflchef/tflite/src/Op/TopKV2.cpp
new file mode 100644
index 000000000..461456ae2
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/TopKV2.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TopKV2.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpTopKV2::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // filler for second input
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[1]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32 ||
+         tensor->type() == tflite::TensorType::TensorType_INT64);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+  auto vec = extract_buffer<int32_t>(buffer);
+  import->set_tensor_filler(inputs[1], vec);
+}
+
+tflchef::Operation *TFliteOpTopKV2::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("TopKV2");
+
+  // NOTE there is `sorted` attribute in TF but it's always true for TFlite
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/TopKV2.h b/compiler/tflchef/tflite/src/Op/TopKV2.h
new file mode 100644
index 000000000..b2b74cc75
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/TopKV2.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_TOPK_V2_H__
+#define __TFLITE_OP_TOPK_V2_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for TOPK_V2
+ */
+class TFliteOpTopKV2 : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_TOPK_V2_H__
diff --git a/compiler/tflchef/tflite/src/Op/Transpose.cpp b/compiler/tflchef/tflite/src/Op/Transpose.cpp
index ae97a19e2..a997bb08e 100644
--- a/compiler/tflchef/tflite/src/Op/Transpose.cpp
+++ b/compiler/tflchef/tflite/src/Op/Transpose.cpp
@@ -36,16 +36,11 @@ void TFliteOpTranspose::filler(const tflite::Operator *op, TFliteImport *import,
 tflchef::Operation *TFliteOpTranspose::build(const tflite::Operator *op, TFliteImport *import,
                                              tflchef::ModelRecipe *model_recipe) const
 {
-  auto op_params = op->builtin_options_as<tflite::TransposeOptions>();
-  assert(op_params != nullptr);
-  (void)op_params;
-
   auto operation = model_recipe->add_operation();
 
   operation->set_type("Transpose");
 
-  auto op_options = operation->mutable_transpose_options();
-  (void)op_options;
+  // No options for Transpose
 
   return operation;
 }
diff --git a/compiler/tflchef/tflite/src/Op/TransposeConv.cpp b/compiler/tflchef/tflite/src/Op/TransposeConv.cpp
new file mode 100644
index 000000000..7e772b954
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/TransposeConv.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TransposeConv.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpTransposeConv::filler(const tflite::Operator *op, TFliteImport *import,
+                                   tflchef::ModelRecipe *model_recipe) const
+{
+  const auto &inputs = *op->inputs();
+
+  const tflite::Tensor *tensor = import->tensors()->Get(inputs[0]);
+  assert(tensor->type() == tflite::TensorType::TensorType_INT32);
+  const tflite::Buffer *buffer = import->buffers()->Get(tensor->buffer());
+
+  if (buffer && buffer->data())
+  {
+    auto vec = extract_buffer<int32_t>(buffer);
+    import->set_tensor_filler(inputs[0], vec);
+  }
+}
+
+tflchef::Operation *TFliteOpTransposeConv::build(const tflite::Operator *op, TFliteImport *import,
+                                                 tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_TransposeConvOptions();
+
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("TransposeConv");
+
+  auto op_options = operation->mutable_transpose_conv_options();
+
+  op_options->set_stride_h(op_params->stride_h());
+  op_options->set_stride_w(op_params->stride_w());
+  op_options->set_padding(as_tflchef_padding(op_params->padding()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/TransposeConv.h b/compiler/tflchef/tflite/src/Op/TransposeConv.h
new file mode 100644
index 000000000..c79cdabd2
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/TransposeConv.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_TRANSPOSE_CONV_H__
+#define __TFLITE_OP_TRANSPOSE_CONV_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for TransposeConv
+ */
+class TFliteOpTransposeConv : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_TRANSPOSE_CONV_H__
diff --git a/compiler/tflchef/tflite/src/Op/Unique.cpp b/compiler/tflchef/tflite/src/Op/Unique.cpp
new file mode 100644
index 000000000..e3f77f40e
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Unique.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Unique.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpUnique::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpUnique::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto op_params = op->builtin_options_as_UniqueOptions();
+  assert(op_params != nullptr);
+
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Unique");
+
+  auto op_options = operation->mutable_unique_options();
+
+  op_options->set_idx_out_type(as_tflchef_type(op_params->idx_out_type()));
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Unique.h b/compiler/tflchef/tflite/src/Op/Unique.h
new file mode 100644
index 000000000..fae037c9f
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Unique.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_UNIQUE_H__
+#define __TFLITE_OP_UNIQUE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Unique
+ */
+class TFliteOpUnique : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_UNIQUE_H__
diff --git a/compiler/tflchef/tflite/src/Op/Unpack.cpp b/compiler/tflchef/tflite/src/Op/Unpack.cpp
new file mode 100644
index 000000000..a51ef84ef
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Unpack.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Unpack.h"
+
+namespace tflchef
+{
+
+void TFliteOpUnpack::filler(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with filler
+}
+
+tflchef::Operation *TFliteOpUnpack::build(const tflite::Operator *op, TFliteImport *import,
+                                          tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+
+  operation->set_type("Unpack");
+
+  auto op_params = op->builtin_options_as_UnpackOptions();
+  assert(op_params != nullptr);
+
+  auto op_options = operation->mutable_unpack_options();
+  op_options->set_num(op_params->num());
+  op_options->set_axis(op_params->axis());
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Unpack.h b/compiler/tflchef/tflite/src/Op/Unpack.h
new file mode 100644
index 000000000..1036bdc14
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Unpack.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_UNPACK_H__
+#define __TFLITE_OP_UNPACK_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Unpack
+ */
+class TFliteOpUnpack : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_UNPACK_H__
diff --git a/compiler/tflchef/tflite/src/Op/Where.cpp b/compiler/tflchef/tflite/src/Op/Where.cpp
new file mode 100644
index 000000000..e42de3737
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Where.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Where.h"
+
+namespace tflchef
+{
+
+void TFliteOpWhere::filler(const tflite::Operator *, TFliteImport *, tflchef::ModelRecipe *) const
+{
+  // Nothing to do with fillers here
+}
+
+tflchef::Operation *TFliteOpWhere::build(const tflite::Operator *, TFliteImport *,
+                                         tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("Where");
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/Where.h b/compiler/tflchef/tflite/src/Op/Where.h
new file mode 100644
index 000000000..00cdc4b00
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/Where.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_WHERE_H__
+#define __TFLITE_OP_WHERE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for Where
+ */
+class TFliteOpWhere : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_WHERE_H__
diff --git a/compiler/tflchef/tflite/src/Op/ZerosLike.cpp b/compiler/tflchef/tflite/src/Op/ZerosLike.cpp
new file mode 100644
index 000000000..a56b6bdfb
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ZerosLike.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ZerosLike.h"
+
+#include "Convert.h"
+
+namespace tflchef
+{
+
+void TFliteOpZerosLike::filler(const tflite::Operator *op, TFliteImport *import,
+                               tflchef::ModelRecipe *model_recipe) const
+{
+  // Nothing to do with fillers here
+}
+
+tflchef::Operation *TFliteOpZerosLike::build(const tflite::Operator *op, TFliteImport *,
+                                             tflchef::ModelRecipe *model_recipe) const
+{
+  auto operation = model_recipe->add_operation();
+  operation->set_type("ZerosLike");
+
+  auto op_options = operation->mutable_zeros_like_options();
+  (void)op_options;
+
+  return operation;
+}
+
+} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/Op/ZerosLike.h b/compiler/tflchef/tflite/src/Op/ZerosLike.h
new file mode 100644
index 000000000..163c1fa21
--- /dev/null
+++ b/compiler/tflchef/tflite/src/Op/ZerosLike.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __TFLITE_OP_ZEROS_LIKE_H__
+#define __TFLITE_OP_ZEROS_LIKE_H__
+
+#include "TFliteOpChef.h"
+
+namespace tflchef
+{
+
+/**
+ * @brief tflchef operator builder for ZerosLike
+ */
+class TFliteOpZerosLike : public TFliteOpChef
+{
+public:
+  void filler(const tflite::Operator *op, TFliteImport *import,
+              tflchef::ModelRecipe *model_recipe) const override;
+  tflchef::Operation *build(const tflite::Operator *op, TFliteImport *import,
+                            tflchef::ModelRecipe *model_recipe) const override;
+};
+
+} // namespace tflchef
+
+#endif // __TFLITE_OP_ZEROS_LIKE_H__
diff --git a/compiler/tflchef/tflite/src/RawModelLoader.cpp b/compiler/tflchef/tflite/src/RawModelLoader.cpp
deleted file mode 100644
index e9ef8ec8b..000000000
--- a/compiler/tflchef/tflite/src/RawModelLoader.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd. All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <tflchef/RawModel.h>
-
-#include <cwrap/Fildes.h>
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-
-namespace
-{
-
-class MemoryMappedRawModel final : public tflchef::RawModel
-{
-public:
-  /**
-   * @require fd and data SHOULD be valid
-   */
-  explicit MemoryMappedRawModel(int fd, void *data, size_t size) : _fd{fd}, _data{data}, _size{size}
-  {
-    // DO NOTHING
-  }
-
-public:
-  ~MemoryMappedRawModel()
-  {
-    munmap(_data, _size);
-    close(_fd);
-  }
-
-public:
-  MemoryMappedRawModel(const MemoryMappedRawModel &) = delete;
-  MemoryMappedRawModel(MemoryMappedRawModel &&) = delete;
-
-public:
-  const ::tflite::Model *model(void) const override { return ::tflite::GetModel(_data); }
-
-private:
-  int _fd = -1;
-  void *_data = nullptr;
-  size_t _size = 0;
-};
-
-} // namespace
-
-namespace tflchef
-{
-
-std::unique_ptr<RawModel> load_tflite(const std::string &path)
-{
-  cwrap::Fildes fildes{open(path.c_str(), O_RDONLY)};
-
-  if (fildes.get() == -1)
-  {
-    // Return nullptr on open failure
-    return nullptr;
-  }
-
-  struct stat st;
-  if (fstat(fildes.get(), &st) == -1)
-  {
-    // Return nullptr on fstat failure
-    return nullptr;
-  }
-
-  auto size = st.st_size;
-  auto data = mmap(nullptr, size, PROT_READ, MAP_SHARED, fildes.get(), 0);
-
-  if (data == MAP_FAILED)
-  {
-    // Return nullptr on mmap failure
-    return nullptr;
-  }
-
-  return std::unique_ptr<tflchef::RawModel>{new MemoryMappedRawModel(fildes.release(), data, size)};
-}
-
-} // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/RecipeChef.cpp b/compiler/tflchef/tflite/src/RecipeChef.cpp
index 407006b26..db62d0e40 100644
--- a/compiler/tflchef/tflite/src/RecipeChef.cpp
+++ b/compiler/tflchef/tflite/src/RecipeChef.cpp
@@ -35,9 +35,16 @@ void set_inputs(TFliteImport *import, tflchef::Operation *operation, const tflit
 
   for (auto input : inputs)
   {
-    auto tensor = tensors->Get(input);
-    std::string name = tensor_name(tensor);
-    operation->add_input(name);
+    if (input == -1)
+    {
+      operation->add_input("");
+    }
+    else
+    {
+      auto tensor = tensors->Get(input);
+      std::string name = tensor_name(tensor);
+      operation->add_input(name);
+    }
   }
 }
 
@@ -104,11 +111,14 @@ std::unique_ptr<ModelRecipe> generate_recipe(const tflite::Model *model)
     operand->set_name(tensor_name(tensor));
     operand->set_type(as_tflchef_type(tensor->type()));
 
-    std::vector<int32_t> dims = as_index_vector(tensor->shape());
-    ::tflchef::TensorShape *shape = operand->mutable_shape();
-    for (auto dim : dims)
+    if (tensor->shape())
     {
-      shape->add_dim(dim);
+      std::vector<int32_t> dims = as_index_vector(tensor->shape());
+      ::tflchef::TensorShape *shape = operand->mutable_shape();
+      for (auto dim : dims)
+      {
+        shape->add_dim(dim);
+      }
     }
 
     // filler for weights, bias and so on
diff --git a/compiler/tflchef/tflite/src/TFliteImport.h b/compiler/tflchef/tflite/src/TFliteImport.h
index fa8196405..5b46f4501 100644
--- a/compiler/tflchef/tflite/src/TFliteImport.h
+++ b/compiler/tflchef/tflite/src/TFliteImport.h
@@ -121,18 +121,18 @@ public:
   }
 
 private:
-  const TFliteSubGraphs_t *_subgraphs;
-  const TFliteBuffers_t *_buffers;
-  const TFliteTensors_t *_tensors;
-  const TFliteOperators_t *_operators;
-
-  std::vector<const tflite::OperatorCode *> _op_codes;
-  std::vector<int32_t> _inputs;
-  std::vector<int32_t> _outputs;
-
-  std::map<uint32_t, bool> _tensor_filler;
-  std::map<uint32_t, std::vector<int32_t>> _tensor_filler_vint32;
-  std::map<uint32_t, std::vector<float>> _tensor_filler_vfloat;
+  const TFliteSubGraphs_t *_subgraphs{nullptr};
+  const TFliteBuffers_t *_buffers{nullptr};
+  const TFliteTensors_t *_tensors{nullptr};
+  const TFliteOperators_t *_operators{nullptr};
+
+  std::vector<const tflite::OperatorCode *> _op_codes{};
+  std::vector<int32_t> _inputs{};
+  std::vector<int32_t> _outputs{};
+
+  std::map<uint32_t, bool> _tensor_filler{};
+  std::map<uint32_t, std::vector<int32_t>> _tensor_filler_vint32{};
+  std::map<uint32_t, std::vector<float>> _tensor_filler_vfloat{};
 };
 
 } // namespace tflchef
diff --git a/compiler/tflchef/tflite/src/TFliteOpChefs.h b/compiler/tflchef/tflite/src/TFliteOpChefs.h
index 685d6861b..ad52af1c2 100644
--- a/compiler/tflchef/tflite/src/TFliteOpChefs.h
+++ b/compiler/tflchef/tflite/src/TFliteOpChefs.h
@@ -20,32 +20,104 @@
 // In alphabet order
 #include "Op/Abs.h"
 #include "Op/Add.h"
+#include "Op/AddN.h"
 #include "Op/ArgMax.h"
+#include "Op/ArgMin.h"
 #include "Op/AveragePool2D.h"
+#include "Op/BatchMatMul.h"
 #include "Op/BatchToSpaceND.h"
+#include "Op/Cast.h"
+#include "Op/Ceil.h"
 #include "Op/Concatenation.h"
 #include "Op/Conv2D.h"
 #include "Op/Cos.h"
+#include "Op/DepthToSpace.h"
 #include "Op/DepthwiseConv2D.h"
 #include "Op/Div.h"
+#include "Op/ELU.h"
 #include "Op/Equal.h"
 #include "Op/Exp.h"
+#include "Op/ExpandDims.h"
+#include "Op/Fill.h"
+#include "Op/Floor.h"
 #include "Op/FloorDiv.h"
+#include "Op/FloorMod.h"
 #include "Op/FullyConnected.h"
+#include "Op/Gather.h"
+#include "Op/GatherNd.h"
+#include "Op/Greater.h"
+#include "Op/GreaterEqual.h"
+#include "Op/L2Normalize.h"
+#include "Op/L2Pool2D.h"
+#include "Op/LeakyRelu.h"
+#include "Op/Less.h"
+#include "Op/LessEqual.h"
+#include "Op/LocalResponseNormalization.h"
+#include "Op/Log.h"
+#include "Op/LogicalAnd.h"
 #include "Op/LogicalNot.h"
 #include "Op/LogicalOr.h"
+#include "Op/Logistic.h"
+#include "Op/LogSoftmax.h"
+#include "Op/MatrixDiag.h"
+#include "Op/MatrixSetDiag.h"
+#include "Op/Maximum.h"
 #include "Op/MaxPool2D.h"
 #include "Op/Mean.h"
+#include "Op/Minimum.h"
+#include "Op/MirrorPad.h"
+#include "Op/Mul.h"
+#include "Op/Neg.h"
+#include "Op/NotEqual.h"
+#include "Op/OneHot.h"
 #include "Op/Pack.h"
 #include "Op/Pad.h"
+#include "Op/Pow.h"
+#include "Op/PRelu.h"
+#include "Op/Range.h"
+#include "Op/Rank.h"
+#include "Op/ReduceAny.h"
+#include "Op/ReduceMax.h"
+#include "Op/ReduceMin.h"
+#include "Op/ReduceProd.h"
 #include "Op/ReLU.h"
 #include "Op/ReLU6.h"
+#include "Op/ReLUN1To1.h"
 #include "Op/Reshape.h"
+#include "Op/ResizeBilinear.h"
+#include "Op/ResizeNearestNeighbor.h"
+#include "Op/ReverseSequence.h"
+#include "Op/ReverseV2.h"
+#include "Op/Round.h"
 #include "Op/Rsqrt.h"
+#include "Op/ScatterNd.h"
+#include "Op/SegmentSum.h"
+#include "Op/Select.h"
+#include "Op/SelectV2.h"
+#include "Op/Shape.h"
+#include "Op/Sin.h"
+#include "Op/Slice.h"
 #include "Op/Softmax.h"
+#include "Op/SpaceToBatchND.h"
+#include "Op/SpaceToDepth.h"
+#include "Op/SparseToDense.h"
+#include "Op/Split.h"
+#include "Op/SplitV.h"
 #include "Op/Sqrt.h"
+#include "Op/Square.h"
+#include "Op/SquaredDifference.h"
+#include "Op/Squeeze.h"
+#include "Op/StridedSlice.h"
 #include "Op/Sub.h"
+#include "Op/Sum.h"
 #include "Op/Tanh.h"
+#include "Op/Tile.h"
+#include "Op/TopKV2.h"
 #include "Op/Transpose.h"
+#include "Op/TransposeConv.h"
+#include "Op/Unique.h"
+#include "Op/Unpack.h"
+#include "Op/Where.h"
+#include "Op/ZerosLike.h"
 
 #endif // __TFLITE_OP_CHEFS_H__
diff --git a/compiler/tflchef/tflite/src/TFliteOpRegistry.h b/compiler/tflchef/tflite/src/TFliteOpRegistry.h
index f0aed2113..0a44b3f06 100644
--- a/compiler/tflchef/tflite/src/TFliteOpRegistry.h
+++ b/compiler/tflchef/tflite/src/TFliteOpRegistry.h
@@ -57,33 +57,105 @@ private:
 
     REG_TFL_OP(ABS, TFliteOpAbs);
     REG_TFL_OP(ADD, TFliteOpAdd);
+    REG_TFL_OP(ADD_N, TFliteOpAddN);
     REG_TFL_OP(ARG_MAX, TFliteOpArgMax);
+    REG_TFL_OP(ARG_MIN, TFliteOpArgMin);
     REG_TFL_OP(AVERAGE_POOL_2D, TFliteOpAveragePool2D);
+    REG_TFL_OP(BATCH_MATMUL, TFliteOpBatchMatMul);
     REG_TFL_OP(BATCH_TO_SPACE_ND, TFliteOpBatchToSpaceND);
+    REG_TFL_OP(CAST, TFliteOpCast);
+    REG_TFL_OP(CEIL, TFliteOpCeil);
     REG_TFL_OP(CONCATENATION, TFliteOpConcatenation);
     REG_TFL_OP(CONV_2D, TFliteOpConv2D);
     REG_TFL_OP(COS, TFliteOpCos);
+    REG_TFL_OP(DEPTH_TO_SPACE, TFliteOpDepthToSpace);
     REG_TFL_OP(DEPTHWISE_CONV_2D, TFliteOpDepthwiseConv2D);
     REG_TFL_OP(DIV, TFliteOpDiv);
+    REG_TFL_OP(ELU, TFliteOpELU);
     REG_TFL_OP(EQUAL, TFliteOpEqual);
     REG_TFL_OP(EXP, TFliteOpExp);
+    REG_TFL_OP(EXPAND_DIMS, TFliteOpExpandDims);
+    REG_TFL_OP(FILL, TFliteOpFill);
+    REG_TFL_OP(FLOOR, TFliteOpFloor);
     REG_TFL_OP(FLOOR_DIV, TFliteOpFloorDiv);
+    REG_TFL_OP(FLOOR_MOD, TFliteOpFloorMod);
     REG_TFL_OP(FULLY_CONNECTED, TFliteOpFullyConnected);
+    REG_TFL_OP(GATHER, TFliteOpGather);
+    REG_TFL_OP(GATHER_ND, TFliteOpGatherNd);
+    REG_TFL_OP(GREATER, TFliteOpGreater);
+    REG_TFL_OP(GREATER_EQUAL, TFliteOpGreaterEqual);
+    REG_TFL_OP(L2_NORMALIZATION, TFliteOpL2Normalize);
+    REG_TFL_OP(L2_POOL_2D, TFliteOpL2Pool2D);
+    REG_TFL_OP(LEAKY_RELU, TFliteOpLeakyRelu);
+    REG_TFL_OP(LESS, TFliteOpLess);
+    REG_TFL_OP(LESS_EQUAL, TFliteOpLessEqual);
+    REG_TFL_OP(LOCAL_RESPONSE_NORMALIZATION, TFliteOpLocalResponseNormalization);
+    REG_TFL_OP(LOG, TFliteOpLog);
+    REG_TFL_OP(LOGICAL_AND, TFliteOpLogicalAnd);
     REG_TFL_OP(LOGICAL_NOT, TFliteOpLogicalNot);
     REG_TFL_OP(LOGICAL_OR, TFliteOpLogicalOr);
+    REG_TFL_OP(LOGISTIC, TFliteOpLogistic);
+    REG_TFL_OP(LOG_SOFTMAX, TFliteOpLogSoftmax);
+    REG_TFL_OP(MATRIX_DIAG, TFliteOpMatrixDiag);
     REG_TFL_OP(MAX_POOL_2D, TFliteOpMaxPool2D);
+    REG_TFL_OP(MATRIX_SET_DIAG, TFliteOpMatrixSetDiag);
+    REG_TFL_OP(MAXIMUM, TFliteOpMaximum);
     REG_TFL_OP(MEAN, TFliteOpMean);
+    REG_TFL_OP(MINIMUM, TFliteOpMinimum);
+    REG_TFL_OP(MIRROR_PAD, TFliteOpMirrorPad);
+    REG_TFL_OP(MUL, TFliteOpMul);
+    REG_TFL_OP(NEG, TFliteOpNeg);
+    REG_TFL_OP(NOT_EQUAL, TFliteOpNotEqual);
+    REG_TFL_OP(ONE_HOT, TFliteOpOneHot);
     REG_TFL_OP(PACK, TFliteOpPack);
     REG_TFL_OP(PAD, TFliteOpPad);
+    REG_TFL_OP(POW, TFliteOpPow);
+    REG_TFL_OP(PRELU, TFliteOpPRelu);
+    REG_TFL_OP(RANGE, TFliteOpRange);
+    REG_TFL_OP(RANK, TFliteOpRank);
+    REG_TFL_OP(REDUCE_ANY, TFliteOpReduceAny);
+    REG_TFL_OP(REDUCE_MAX, TFliteOpReduceMax);
+    REG_TFL_OP(REDUCE_MIN, TFliteOpReduceMin);
+    REG_TFL_OP(REDUCE_PROD, TFliteOpReduceProd);
     REG_TFL_OP(RELU, TFliteOpReLU);
     REG_TFL_OP(RELU6, TFliteOpReLU6);
+    REG_TFL_OP(RELU_N1_TO_1, TFliteOpReLUN1To1);
     REG_TFL_OP(RESHAPE, TFliteOpReshape);
+    REG_TFL_OP(RESIZE_BILINEAR, TFliteOpResizeBilinear);
+    REG_TFL_OP(RESIZE_NEAREST_NEIGHBOR, TFliteOpResizeNearestNeighbor);
+    REG_TFL_OP(REVERSE_SEQUENCE, TFliteOpReverseSequence);
+    REG_TFL_OP(REVERSE_V2, TFliteOpReverseV2);
+    REG_TFL_OP(ROUND, TFliteOpRound);
     REG_TFL_OP(RSQRT, TFliteOpRsqrt);
+    REG_TFL_OP(SCATTER_ND, TFliteOpScatterNd);
+    REG_TFL_OP(SEGMENT_SUM, TFliteOpSegmentSum);
+    REG_TFL_OP(SELECT, TFliteOpSelect);
+    REG_TFL_OP(SELECT_V2, TFliteOpSelectV2);
+    REG_TFL_OP(SHAPE, TFliteOpShape);
+    REG_TFL_OP(SIN, TFliteOpSin);
+    REG_TFL_OP(SLICE, TFliteOpSlice);
     REG_TFL_OP(SOFTMAX, TFliteOpSoftmax);
+    REG_TFL_OP(SPACE_TO_BATCH_ND, TFliteOpSpaceToBatchND);
+    REG_TFL_OP(SPACE_TO_DEPTH, TFliteOpSpaceToDepth);
+    REG_TFL_OP(SPARSE_TO_DENSE, TFliteOpSparseToDense);
+    REG_TFL_OP(SPLIT, TFliteOpSplit);
+    REG_TFL_OP(SPLIT_V, TFliteOpSplitV);
     REG_TFL_OP(SQRT, TFliteOpSqrt);
+    REG_TFL_OP(SQUARE, TFliteOpSquare);
+    REG_TFL_OP(SQUARED_DIFFERENCE, TFliteOpSquaredDifference);
+    REG_TFL_OP(SQUEEZE, TFliteOpSqueeze);
+    REG_TFL_OP(STRIDED_SLICE, TFliteOpStridedSlice);
     REG_TFL_OP(SUB, TFliteOpSub);
+    REG_TFL_OP(SUM, TFliteOpSum);
     REG_TFL_OP(TANH, TFliteOpTanh);
+    REG_TFL_OP(TILE, TFliteOpTile);
+    REG_TFL_OP(TOPK_V2, TFliteOpTopKV2);
     REG_TFL_OP(TRANSPOSE, TFliteOpTranspose);
+    REG_TFL_OP(TRANSPOSE_CONV, TFliteOpTransposeConv);
+    REG_TFL_OP(UNIQUE, TFliteOpUnique);
+    REG_TFL_OP(UNPACK, TFliteOpUnpack);
+    REG_TFL_OP(WHERE, TFliteOpWhere);
+    REG_TFL_OP(ZEROS_LIKE, TFliteOpZerosLike);
 
 #undef REG_TFL_OP
   }
diff --git a/compiler/tflchef/tools/file/CMakeLists.txt b/compiler/tflchef/tools/file/CMakeLists.txt
index 477b7d974..f411d60f1 100644
--- a/compiler/tflchef/tools/file/CMakeLists.txt
+++ b/compiler/tflchef/tools/file/CMakeLists.txt
@@ -1,3 +1,4 @@
 add_executable(tflchef-file Driver.cpp)
+target_link_libraries(tflchef-file arser)
 target_link_libraries(tflchef-file tflchef_core)
 target_link_libraries(tflchef-file safemain)
diff --git a/compiler/tflchef/tools/file/Driver.cpp b/compiler/tflchef/tools/file/Driver.cpp
index 3ef701910..cecfeeb3e 100644
--- a/compiler/tflchef/tools/file/Driver.cpp
+++ b/compiler/tflchef/tools/file/Driver.cpp
@@ -20,30 +20,42 @@
 #include <google/protobuf/io/zero_copy_stream_impl.h>
 #include <google/protobuf/text_format.h>
 
+#include <arser/arser.h>
+
 #include <fstream>
 #include <iostream>
 
 int entry(int argc, char **argv)
 {
-  if (argc != 3)
+  arser::Arser arser;
+  arser.add_argument("recipe")
+      .type(arser::DataType::STR)
+      .help("Source recipe file path to convert");
+  arser.add_argument("tflite").type(arser::DataType::STR).help("Target tflite file path");
+
+  try
   {
-    std::cerr << "ERROR: Failed to parse arguments" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "USAGE: " << argv[0] << " [recipe] [output]" << std::endl;
-    return 255;
+    arser.parse(argc, argv);
+  }
+  catch (const std::runtime_error &err)
+  {
+    std::cout << err.what() << std::endl;
+    std::cout << arser;
+    return 0;
   }
 
   int32_t model_version = 1;
 
   ::tflchef::ModelRecipe model_recipe;
 
+  std::string recipe_path = arser.get<std::string>("recipe");
   // Load model recipe from a file
   {
-    std::ifstream is{argv[1]};
+    std::ifstream is{recipe_path};
     google::protobuf::io::IstreamInputStream iis{&is};
     if (!google::protobuf::TextFormat::Parse(&iis, &model_recipe))
     {
-      std::cerr << "ERROR: Failed to parse recipe '" << argv[1] << "'" << std::endl;
+      std::cerr << "ERROR: Failed to parse recipe '" << recipe_path << "'" << std::endl;
       return 255;
     }
 
@@ -62,9 +74,10 @@ int entry(int argc, char **argv)
 
   auto generated_model = tflchef::cook(model_recipe);
 
+  std::string tflite_path = arser.get<std::string>("tflite");
   // Dump generated model into a file
   {
-    std::ofstream os{argv[2], std::ios::binary};
+    std::ofstream os{tflite_path, std::ios::binary};
     os.write(generated_model.base(), generated_model.size());
   }
 
diff --git a/compiler/tflchef/tools/reverse/CMakeLists.txt b/compiler/tflchef/tools/reverse/CMakeLists.txt
index 63cb36c06..a5c0f5bca 100644
--- a/compiler/tflchef/tools/reverse/CMakeLists.txt
+++ b/compiler/tflchef/tools/reverse/CMakeLists.txt
@@ -1,3 +1,5 @@
 add_executable(tflchef-reverse Driver.cpp)
+target_link_libraries(tflchef-reverse arser)
 target_link_libraries(tflchef-reverse tflchef_tflite)
 target_link_libraries(tflchef-reverse safemain)
+target_link_libraries(tflchef-reverse foder)
diff --git a/compiler/tflchef/tools/reverse/Driver.cpp b/compiler/tflchef/tools/reverse/Driver.cpp
index 549756463..1116dec34 100644
--- a/compiler/tflchef/tools/reverse/Driver.cpp
+++ b/compiler/tflchef/tools/reverse/Driver.cpp
@@ -14,34 +14,41 @@
  * limitations under the License.
  */
 
-#include <tflchef/RawModel.h>
 #include <tflchef/RecipeChef.h>
 
+#include <arser/arser.h>
+#include <foder/FileLoader.h>
+
 #include <memory>
 #include <iostream>
 
 int entry(int argc, char **argv)
 {
-  if (argc != 3)
+  arser::Arser arser;
+  arser.add_argument("tflite")
+      .type(arser::DataType::STR)
+      .help("Source tflite file path to convert");
+  arser.add_argument("recipe").type(arser::DataType::STR).help("Target recipe file path");
+
+  try
   {
-    std::cerr << "ERROR: Failed to parse arguments" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "USAGE: " << argv[0] << " [tflite] [output]" << std::endl;
-    return 255;
+    arser.parse(argc, argv);
   }
-
-  // Load TF lite model from a tflite file
-  std::unique_ptr<tflchef::RawModel> rawmodel = tflchef::load_tflite(argv[1]);
-  if (rawmodel == nullptr)
+  catch (const std::runtime_error &err)
   {
-    std::cerr << "ERROR: Failed to load tflite '" << argv[1] << "'" << std::endl;
-    return 255;
+    std::cout << err.what() << std::endl;
+    std::cout << arser;
+    return 0;
   }
 
-  const tflite::Model *tflmodel = rawmodel->model();
+  std::string tflite_path = arser.get<std::string>("tflite");
+  // Load TF lite model from a tflite file
+  const foder::FileLoader fileLoader{tflite_path};
+  std::vector<char> modelData = fileLoader.load();
+  const tflite::Model *tflmodel = tflite::GetModel(modelData.data());
   if (tflmodel == nullptr)
   {
-    std::cerr << "ERROR: Failed to load tflite '" << argv[1] << "'" << std::endl;
+    std::cerr << "ERROR: Failed to load tflite '" << tflite_path << "'" << std::endl;
     return 255;
   }
 
@@ -53,11 +60,12 @@ int entry(int argc, char **argv)
     return 255;
   }
 
+  std::string recipe_path = arser.get<std::string>("recipe");
   // Save to a file
-  bool result = tflchef::write_recipe(argv[2], recipe);
+  bool result = tflchef::write_recipe(recipe_path, recipe);
   if (!result)
   {
-    std::cerr << "ERROR: Failed to write to recipe '" << argv[2] << "'" << std::endl;
+    std::cerr << "ERROR: Failed to write to recipe '" << recipe_path << "'" << std::endl;
     return 255;
   }
   return 0;