// so we could cast safely here.
  auto type = mlir::cast<ShapedType>(value.getType());
  SmallVector<int> new_shape;
  if (type.hasStaticShape()) {
    for (int64_t dim : type.getShape().drop_back()) {
      new_shape.push_back(dim);
    }
  } else {
    new_shape.push_back(-1);
  }
  return builder.create<ReshapeOp>(
      value.getLoc(), value,
      builder.create<arith::ConstantOp>(

HeapAlloc dt=24 heapalloc_value=26336904
GoCreate dt=72 new_g=34 new_stack=47 stack=48
GoCreate dt=183 new_g=35 new_stack=47 stack=48
GoCreate dt=15 new_g=36 new_stack=47 stack=48
GoCreate dt=12 new_g=37 new_stack=47 stack=48
GoCreate dt=14 new_g=38 new_stack=47 stack=48
HeapAlloc dt=25 heapalloc_value=26344200
GoCreate dt=9 new_g=39 new_stack=47 stack=48
GoCreate dt=13 new_g=40 new_stack=47 stack=48
GoCreate dt=4 new_g=41 new_stack=47 stack=48

// left if needed.
inline std::vector<int64_t> GetPaddedShape(ArrayRef<int64_t> old_shape,
                                           int new_dims) {
  std::vector<int64_t> new_shape(new_dims, 1);
  std::copy_backward(old_shape.begin(), old_shape.end(), new_shape.end());
  return new_shape;
}

// Helper method that given and 'current_index' representing
// index in broadcasted tensor, get the index in the flat original tensor.

  }

  private void checkAndUpdateState(State oldState, State newState) {
    checkState(
        compareAndUpdateState(oldState, newState),
        "Expected state to be %s, but it was %s",
        oldState,
        newState);
  }

  private boolean compareAndUpdateState(State oldState, State newState) {
    return state.compareAndSet(oldState, newState);
  }

  }

  private void checkAndUpdateState(State oldState, State newState) {
    checkState(
        compareAndUpdateState(oldState, newState),
        "Expected state to be %s, but it was %s",
        oldState,
        newState);
  }

  private boolean compareAndUpdateState(State oldState, State newState) {
    return state.compareAndSet(oldState, newState);
  }

                                       /*shape=*/new_shape,
                                       /*type=*/new_filter_quantized_type);
    } else if (element_type.isa<UniformQuantizedType>()) {
      auto per_tensor_type = element_type.cast<UniformQuantizedType>();
      new_filter_result_type =
          RankedTensorType::getChecked(location,
                                       /*shape=*/new_shape,

      SmallVector<int64_t> new_shape(shape.begin(), shape.end());
      // If dimension of the input type is dynamic. Update the
      // bounds of the dim with the new type if needed.
      for (int i = 0; i < input_ty.getShape().size(); i++) {
        if (hlo::isDynamicDimSize(input_ty.getShape()[i])) {
          new_bounds[i] = new_shape[i];
          new_shape[i] = ShapedType::kDynamic;
        }
      }

	return
}

func AdjustTokenGroups(token Token, resetToDefault bool, newstate *Tokengroups, buflen uint32, prevstate *Tokengroups, returnlen *uint32) (err error) {
	var _p0 uint32
	if resetToDefault {
		_p0 = 1
	}
	r1, _, e1 := syscall.Syscall6(procAdjustTokenGroups.Addr(), 6, uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(newstate)), uintptr(buflen), uintptr(unsafe.Pointer(prevstate)), uintptr(unsafe.Pointer(returnlen)))

        InvalidArgument("Node ", node->name(), " was not found in the graph");
    return;
  }
  tensorflow::shape_inference::ShapeHandle new_shape =
      tensorflow::ShapeHandleFromDims(ic, num_dims, dims);
  status->status = graph->refiner.SetShape(node, output.index, new_shape);
}

int TF_GraphGetTensorNumDims(TF_Graph* graph, TF_Output output,
                             TF_Status* status) {