/** The key of the message: Started a process to delete the document from index. */
    public static final String SUCCESS_delete_doc_from_index = "{success.delete_doc_from_index}";

    /** The key of the message: Deleted session data. */
    public static final String SUCCESS_crawling_info_delete_all = "{success.crawling_info_delete_all}";

        ':santa-tracker:writeDebugAppMetadata': SUCCESS,
        ':santa-tracker:writeDebugModuleMetadata': SUCCESS,
        ':santa-tracker:writeDebugSigningConfigVersions': SUCCESS,
        ':snowballrun:assembleDebug': SUCCESS,
        ':snowballrun:checkDebugAarMetadata': SUCCESS,
        ':snowballrun:checkDebugDuplicateClasses': SUCCESS,
        ':snowballrun:compileDebugJavaWithJavac': FROM_CACHE,

  } else {
    // Neither has a rank.
    return success();
  }

  auto cond_tensor = op.getCondition().getType().dyn_cast<RankedTensorType>();
  if (!cond_tensor) return success();
  auto cond_rank = cond_tensor.getRank();
  // Check (2a) and (2b).
  if (cond_rank == 0 || cond_rank == data_rank) return success();
  // Check (2c).
  if (cond_rank == 1) {

		},
		{
			name:       "error after success status, returns success",
			injects:    []framework.Code{framework.Success, framework.Error},
			wantStatus: framework.Success,
		},
		{
			name:       "success before invalid status, returns success",
			injects:    []framework.Code{framework.Success, framework.Error},
			wantStatus: framework.Success,
		},
		{

  if (!inputs_type) return success();
  int depth = inputs_type.getDimSize(inputs_type.getRank() - 1);
  if ((min && min.getDimSize(0) != depth) ||
      (max && max.getDimSize(0) != depth)) {
    return op.emitOpError(
        "requires min and max to have same size as last dimension of inputs");
  }

  return success();
}

  if (op.getRegions().empty()) return success();
  auto* real_op = &op.getBody().front().front();
  if (llvm::isa<TF::FakeQuantWithMinMaxArgsOp, TF::FakeQuantWithMinMaxVarsOp,
                TF::FakeQuantWithMinMaxVarsPerChannelOp>(real_op)) {
    Value input = *operands.begin();
    inferredReturnTypes.assign({input.getType()});
  }
  return success();
}

				st.MakeNode().Name("node-y").Label("zone", "zone2").Label("node", "node-y").Obj(),
			},
			wantStatusCode: map[string]framework.Code{
				"node-a": framework.Success,
				"node-b": framework.Success,
				"node-x": framework.Success,
				"node-y": framework.Success,
			},
		},
		{
			name: "no existing pods, incoming pod doesn't match itself",
			pod: st.MakePod().Name("p").Label("foo", "").

        align_corners = true;
        return success();
      }
      if (can_convert_to_bilinear(
              /*align_corners=*/false, lhs_dilation_values[0],
              padding_values[0], window_strides_values[0], input_sizes[0],
              output_sizes[0])) {
        align_corners = false;
        return success();
      }
    }

			}, nil
		},
		afterUpdate: func(obj runtime.Object, opts *metav1.UpdateOptions) {
			mile("AfterUpdate")
		},
		beginUpdate: func(_ context.Context, obj, _ runtime.Object, _ *metav1.UpdateOptions) (FinishFunc, error) {
			mile("BeginUpdate")
			return func(_ context.Context, success bool) {
				mile(fmt.Sprintf("FinishUpdate(%v)", success))
			}, nil
		},

        return failure();
      }
      return success();
    }
    if (!IsI8F32UniformQuantizedType(output_element_type)) {
      LLVM_DEBUG(
          llvm::dbgs()
          << "Expected a per-tensor uniform quantized (i8->f32) type. Got: "
          << output_element_type << ".\n");
      return failure();
    }
    return success();
  }

  static void RewriteDotGeneralToTflBatchMatmulOp(