namespace mlir {
namespace quant {

LogicalResult RemoveIdentity::matchAndRewrite(TF::IdentityOp identity,
                                              PatternRewriter &rewriter) const {
  for (Operation *user : identity->getUsers()) {
    // Replace the op with the input if output is only used by TF ops.
    // Currently this is more on the conservative side since we need to ensure
    // every consumer op to be a TF op before applying this pattern. We can

        freezeable[val] = false;
        continue;
      }

      freezeable[val] = true;

      // Verify users are supported kind.
      for (Operation *user : val.getUsers()) {
        if (!(isa<TF::ReadVariableOp>(user) || isa<CallOpInterface>(user))) {
          freezeable[val] = false;
          // Error out early if possible.
          if (!allow_mutable_tensors) {

    @Test
    public void directoryInitializedWithSensibleDefaults() {
        DefaultConfigurableFilePermissions permissions = newPermission(true);
        assertPermissions(permissions.getUser(), true, true, true);
        assertPermissions(permissions.getGroup(), true, false, true);
        assertPermissions(permissions.getOther(), true, false, true);
        assertEquals(0755, permissions.toUnixNumeric());
    }

    }

    private static long calculateAverageUsage(Collection<GarbageCollectionEvent> events) {
        long sum = 0;
        for (GarbageCollectionEvent event : events) {
            sum += event.getUsage().getUsed();
        }
        return sum / events.size();
    }

    private static long findMaxSize(Collection<GarbageCollectionEvent> events) {

     */
    Set<ModularizationOption> getModularizationOptions();

    /**
     * Returns the set of DSLs supported for this type of project, in display order.
     */
    Set<BuildInitDsl> getDsls();

    /**
     * The preferred DSL to use for this type of project.
     */
    BuildInitDsl getDefaultDsl();

    /**
     * Does a project name make sense for this type of project?
     */

            op.rangeSize(fessConfig.getPagingPageRangeSizeAsInteger());
        }).createPageNumberList());

        return userList;
    }

    public OptionalEntity<User> getUser(final String id) {
        return userBhv.selectByPK(id).map(u -> ComponentUtil.getAuthenticationManager().load(u));
    }

    public OptionalEntity<User> getUserByName(final String username) {

  private List<E> values;
  private E a;
  private E b;
  private E c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableSet = (NavigableSet<E>) getSet();
    values =
        Helpers.copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));

                @Internal
                public ListProperty<Integer> getList() {
                    return list;
                }

                @Internal
                public SetProperty<Integer> getSet() {
                    return set;
                }

                @Internal
                public MapProperty<Integer, Boolean> getMap() {
                    return map;
                }

        this.buildTreeScopedCacheBuilderFactory = buildTreeScopedCacheBuilderFactory;
        this.generator = generator;
        this.storeFactory = storeFactory;
    }

    @Override
    public UserScopeId getUser() {
        UniqueId uniqueId = get(new ScopeParams(userScopeCacheScopeMarker(), USER_ID_FILENAME, "User ID"));
        return new UserScopeId(uniqueId);
    }

    @Override
    public WorkspaceScopeId getWorkspace() {

    // future.
    OpBuilder b(op);
    RankedTensorType type = RankedTensorType::get({}, b.getIntegerType(32));
    int index = op.getDeviceNames().size();
    for (auto use : op.getOperation()->getUsers()) {
      // Skip if it doesn't feed into case. Alternatively this could always
      // return the CPU device index if it exists.
      if (!isa<TF::CaseOp>(use)) return;
    }
    DenseElementsAttr attr =