*
     * This is called after the underlying Executor has been stopped.
     */
    void onStop();

    /**
     * Runs the Runnable, catches all Throwables and logs them.
     *
     * The first exception caught during onExecute(), will be rethrown in onStop().
     */
    class CatchAndRecordFailures implements ExecutorPolicy {

        Suggest.createContent();
        Logger.info("Create suggest index.");
        Suggest.createSuggestFromContent();
        Logger.info("Finished setup suggest.");
    }

    @Override
    public void onStop(Application var1) {
        ComponentsUtil.runner.close();
        ComponentsUtil.runner.clean();
    }

    private void esRun() {
        ElasticsearchClusterRunner runner = new ElasticsearchClusterRunner();

            }
        } catch (InterruptedException e) {
            delegate.shutdownNow();
            throw UncheckedException.throwAsUncheckedException(e);
        }
        executorPolicy.onStop();
    }

    @Override
    public void setKeepAlive(int timeout, TimeUnit timeUnit) {
        if (delegate instanceof ThreadPoolExecutor) {

            addToQueue(flushOperationsCommand);
            flushOperationsCommand.await();
        }
        rethrowFailure();
    }

    private void rethrowFailure() {
        failureHandler.onStop();
    }

    private static class FlushOperationsCommand implements Runnable {
        private CountDownLatch latch = new CountDownLatch(1);

        @Override
        public void run() {
        }

PLandroidx/lifecycle/ReportFragment$LifecycleCallbacks;->onActivityStopped(Landroid/app/Activity;)V
PLandroidx/lifecycle/ReportFragment;->onDestroy()V
PLandroidx/lifecycle/ReportFragment;->onPause()V
PLandroidx/lifecycle/ReportFragment;->onStop()V

  MLIRContext ctx_;
};

TF::ConstOp ParseConstOp(const absl::string_view const_op_str, Block& block,
                         MLIRContext& ctx) {
  const LogicalResult parse_result =
      parseSourceString(const_op_str, &block, ParserConfig(&ctx));
  EXPECT_TRUE(succeeded(parse_result));

  auto const_op = dyn_cast_or_null<TF::ConstOp>(block.front());
  EXPECT_TRUE(const_op);

  return const_op;
}

        var_handle_op &&
        isa<TF::ConstOp>(assigned_value_operand.getDefiningOp())) {
      var_handle_ops.emplace_back(var_handle_op);
    }
  }

  return var_handle_ops;
}

// Creates a `ConstOp` of 1-dimensional TF::StringType out of `str_values`.
TF::ConstOp Create1DStringConst(const ArrayRef<std::string> str_values,

    auto const_op =
        dyn_cast<TF::ConstOp>(assigned_value_operand.getDefiningOp());
    if (!const_op) continue;

    var_handle_ops.emplace_back(var_handle_op);
  }

  return var_handle_ops;
}

// Creates a `ConstOp` of 1-dimensional TF::StringType out of `str_values`.
TF::ConstOp Create1DStringConst(const ArrayRef<std::string> str_values,

// ReadVariableOp patterns. The ConstOps are not erased. Returns the ConstOp ->
// shared_name mapping. The shared_name is the shared name of the corresponding
// VarHandleOp.
llvm::MapVector<TF::ConstOp, std::string> ReplaceConstOpUsesWithVariableReads(
    llvm::ArrayRef<TF::ConstOp> target_const_ops) {
  llvm::MapVector<TF::ConstOp, std::string> const_op_name_map{};

int64_t GetSizeOfIntOrFloatConst(TF::ConstOp const_op) {
  const Type dtype = const_op.getDtype();
  const ElementsAttr const_value = const_op.getValue();

  const auto bytes_per_elem =
      static_cast<int64_t>(dtype.getIntOrFloatBitWidth() / CHAR_BIT);

  return bytes_per_elem * const_value.getNumElements();
}

int64_t GetSizeOfStringConst(TF::ConstOp const_op) {