// and then propagates constant facts only along reachable control flow paths.
// Since some basic blocks are not visited yet, corresponding inputs of phi become
// Top, we use the meet(phi) to compute its lattice.
//
// 	  Top ∩ any = any
// 	  Bottom ∩ any = Bottom
// 	  ConstantA ∩ ConstantA = ConstantA
// 	  ConstantA ∩ ConstantB = Bottom
//
// Each lattice value is lowered most twice(Top to Constant, Constant to Bottom)

    private void method() {
        for ($constantType i = Constant1.CONSTANT1 $addition; i < Constant2.CONSTANT2 $addition; i += Constant3.CONSTANT3 $addition) {
        }
        $constantType value = Constant3.CONSTANT3 $addition;
        switch((int) value) {
            case (int) (Constant4.CONSTANT4 $addition):
            default:
                value = (int) (Constant5.CONSTANT5 $addition);
        }

class Constant : public TensorHandleConvertible {
 public:
  static Status Create(ImmediateExecutionContext* ctx,
                       AbstractTensorInterface* tensor,
                       std::unique_ptr<Constant>* output);

  // RevivedConstant is movable, but not copyable.
  Constant(Constant&& other) = default;
  Constant& operator=(Constant&& other) = default;

#include "tensorflow/core/platform/types.h"

namespace tensorflow {

Constant::Constant(ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)) {}

Status Constant::Create(ImmediateExecutionContext* ctx,
                        AbstractTensorInterface* tensor,
                        std::unique_ptr<Constant>* output) {
  ImmediateExecutionTensorHandle* handle = ctx->CreateLocalHandle(tensor);

func.func @testConcatOffsetWithZeros() -> (tensor<3xi32>, tensor<3xi32>, tensor<3xi32>, tensor<3xi32>) {
  %concat_dim = arith.constant dense<1> : tensor<i32>
  %shape0 = arith.constant dense<0> : tensor<3xi32>
  %shape1 = arith.constant dense<[0, 3, 0]> : tensor<3xi32>
  %shape2 = arith.constant dense<[0, 5, 0]> : tensor<3xi32>
  %shape3 = arith.constant dense<0> : tensor<3xi32>

  // CHECK-DAG: [[OFFSET_0:%.*]] = "tf.Const{{.*}} dense<0> : tensor<3xi32>

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package constants

// Command line arguments
const (
	// Install
	MountedCNINetDir     = "mounted-cni-net-dir"
	CNINetDir            = "cni-net-dir"
	CNIConfName          = "cni-conf-name"

// See the License for the specific language governing permissions and
// limitations under the License.

package constants

const (
	// UnspecifiedIP constant for empty IP address
	UnspecifiedIP = "0.0.0.0"
	// UnspecifiedIPv6 constant for empty IPv6 address
	UnspecifiedIPv6 = "::"

	// PilotWellKnownDNSCertPath is the path location for Pilot dns serving cert, often used with custom CA integrations

    func.return %1 : tensor<10x19xf32>
  }
}

// Tests that foldable ops are constant-folded to enable legalization of ops
// that require compile time constant operand.
// "tf.Shape" can only be folded away after shape inference. tf.Reshape can only
// be lowered when tf.Shape is folded into a constant.

// CHECK-LABEL: HloModule main

// Test for partial folding: only fold i32 constants.
// RUN: tac-opt-all-backends -tfl-fold-constants-to-subgraph='fold-all-constants=false' %s -split-input-file -verify-diagnostics | FileCheck --check-prefix=PARTIAL %s

// Test for fold all constants.
// RUN: tac-opt-all-backends -tfl-fold-constants-to-subgraph='fold-all-constants=true' %s -split-input-file -verify-diagnostics | FileCheck --check-prefix=ALL %s

module {

// CHECK:         [[CONSTANT:%.*]] = s32[0]{0} constant({})
// CHECK:         ROOT %tuple.{{[0-9]+}} = (s32[0]{0}, s32[0]{0}) tuple(s32[0]{0} [[CONSTANT]], s32[0]{0} [[CONSTANT]])
// CHECK:       }

// NO_TUPLES-LABEL: HloModule main
// NO_TUPLES:       ENTRY %main.{{[0-9+]}} () -> (s32[0], s32[0]) {
// NO_TUPLES:         [[CONSTANT:%.*]] = s32[0]{0} constant({})