name:  "Select reserved word column",
			query: `select "CAST"  from s3object`,
			wantResult: `true
false`,
		},
		{
			name:  "Select reserved word column with table alias",
			query: `select S3Object."CAST" from s3object`,
			wantResult: `true
false`,
		},
		{
			name:  "Select reserved word column with unused table alias",
			query: `select "CAST"  from s3object s`,
			wantResult: `true
false`,

  // CHECK: [[VAL15:%.+]] = "tf.Cast"([[VAL10]]#1)
  // CHECK: [[VAL16:%.+]] = "tf.Div"([[VAL15]], [[VAL6]])
  // CHECK: [[VAL17:%.+]] = "tf.Mul"([[VAL16]], [[VAL5]])
  // CHECK: [[VAL18:%.+]] = "tf.Cast"([[VAL17]])
  // CHECK: [[VAL19:%.+]] = "tf.Reshape"([[VAL18]], [[VAL1]])
  // CHECK: [[VAL20:%.+]] = "tf.Mul"([[VAL19]], [[VAL10]]#2)
  // CHECK: [[VAL21:%.+]] = "tf.Cast"([[VAL10]]#2)

        result_shape, list_element_ty.getElementType());

    // If the list is empty, directly create the final result instead of
    // creating the tf.Pack op. tf.Pack op requires at least one operand.
    if (tensors.empty()) {
      tensorflow::Tensor tensor(list->element_dtype,
                                tensorflow::TensorShape(result_shape));

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.service;

import org.gradle.api.Action;
import org.gradle.internal.Cast;
import org.gradle.internal.Factory;
import org.gradle.internal.concurrent.CompositeStoppable;
import org.gradle.internal.concurrent.Stoppable;

import javax.annotation.Nullable;
import java.io.Closeable;

      // Pull this from the original operands to the original while op.
      auto arg = llvm::cast<BlockArgument>(operand);
      f_operands.push_back(loop_operands[arg.getArgNumber()]);
      continue;
    }
    auto src = operand.getDefiningOp();
    auto res = llvm::cast<OpResult>(operand);
    if (src == non_tpu_caller) {
      f_operands.push_back(non_tpu_res[res.getResultNumber()]);

    return iterator.hasNext() ? iterator.next() : defaultValue;
  }

  /**
   * Advances {@code iterator} to the end, returning the last element.
   *
   * @return the last element of {@code iterator}
   * @throws NoSuchElementException if the iterator is empty
   */
  @ParametricNullness
  public static <T extends @Nullable Object> T getLast(Iterator<T> iterator) {

    return iterator.hasNext() ? iterator.next() : defaultValue;
  }

  /**
   * Advances {@code iterator} to the end, returning the last element.
   *
   * @return the last element of {@code iterator}
   * @throws NoSuchElementException if the iterator is empty
   */
  @ParametricNullness
  public static <T extends @Nullable Object> T getLast(Iterator<T> iterator) {

		}
		klog.V(logLevel).InfoS(logMsg, "svcPortName", svcPortName, "endpoints", epInfo)
	}
}

// This will cleanup stale load balancers which are pending delete
// in last iteration. This function will act like a self healing of stale
// loadbalancer entries.
func (proxier *Proxier) cleanupStaleLoadbalancers() {
	i := 0
	countStaleLB := len(proxier.mapStaleLoadbalancers)

  // CHECK-LABEL: add_v2_uint32
  // CHECK:  %[[CAST:.*]] = "tf.Cast"(%arg0) <{Truncate = false}> : (tensor<ui32>) -> tensor<i32>
  // CHECK:  %[[CAST1:.*]] = "tf.Cast"(%arg1) <{Truncate = false}> : (tensor<ui32>) -> tensor<i32>
  // CHECK:  %[[ADD:.*]] = "tf.AddV2"(%[[CAST]], %[[CAST1]]) : (tensor<i32>, tensor<i32>) -> tensor<i32>
  // CHECK:  %[[CAST2:.*]] = "tf.Cast"(%[[ADD]]) <{Truncate = false}> : (tensor<i32>) -> tensor<ui32>

        dtypes.string, shape=(None,), name='input_vocabs'
    )

    # Introduce a matmul op that takes the lookup values to observe the
    # effects of quantization.
    lookup_vals = math_ops.cast(
        table.lookup(input_vocabs_placeholder), dtypes.float32
    )
    # shape: (2, ?)
    matmul_input = array_ops_stack.stack([lookup_vals, lookup_vals])

    # Create a dummy weight matrix filled with ones.