class AlignTabs<T> implements Consumer<T> {

    @Override
    public void accept(T model) {<FILL_FUNCTION_BODY>}
    
    private static <T> void alignTabs(
        final List<T> models,
        final Function<T, String> getRow,
        final BiConsumer<T, String> setRow
    ) {
        final AtomicInteger maxIndex = new AtomicInteger(-1);
        
        while (true) {
            maxIndex.set(-1);
            
            models.forEach(model -> {
                final String row = getRow.apply(model);
                updateMaxIndex(maxIndex, row);
            });
            
            if (maxIndex.get() > -1) {
                for (final T model : models) {
                    final String row = getRow.apply(model);
                    if (row != null) {
                        final int index = row.indexOf('\t');
                        replaceTabWithSpace(setRow, maxIndex, model, row, index);
                    }
                }
            } else {
                break;
            }
        }
    }

    private static <T> void replaceTabWithSpace(BiConsumer<T, String> setRow, AtomicInteger maxIndex, T model, String row, int index) {
        if (index > -1) {
            setRow.accept(model,
                row.replaceFirst("\t", Formatting.repeat(
                    " ",
                    maxIndex.get() - index
                ))
            );
        }
    }

    private static void updateMaxIndex(AtomicInteger maxIndex, String row) {
        if (row != null) {
            final int index  = row.indexOf('\t');

            if (index > maxIndex.get()) {
                maxIndex.set(index);
            }
        }
    }
}

        if (model instanceof HasCode) {
            @SuppressWarnings("unchecked")
            final HasCode<?> casted = (HasCode<?>) model;
            Formatting.alignTabs(casted.getCode());
        }
        
        if (model instanceof HasClasses) {
            @SuppressWarnings("unchecked")
            final HasClasses<?> casted = (HasClasses<?>) model;
            casted.getClasses().forEach(c -> c.call(new AlignTabs<>()));
        }
        
        if (model instanceof HasMethods) {
            @SuppressWarnings("unchecked")
            final HasMethods<?> casted = (HasMethods<?>) model;
            casted.getMethods().forEach(c -> c.call(new AlignTabs<>()));
        }
        
        if (model instanceof HasConstructors) {
            @SuppressWarnings("unchecked")
            final HasConstructors<?> casted = (HasConstructors<?>) model;
            casted.getConstructors().forEach(c -> c.call(new AlignTabs<>()));
        }
        
        if (model instanceof HasInitializers) {
            @SuppressWarnings("unchecked")
            final HasInitializers<?> casted = (HasInitializers<?>) model;
            casted.getInitializers().forEach(c -> c.call(new AlignTabs<>()));
        }
        
        if (model instanceof HasFields) {
            @SuppressWarnings("unchecked")
            final HasFields<?> casted = (HasFields<?>) model;
            
            alignTabs(casted.getFields(), field -> field.getValue()
                .filter(ReferenceValue.class::isInstance)
                .map(ReferenceValue.class::cast)
                .map(ReferenceValue::getValue)
                .orElse(null),
                    (field, value) -> ((ReferenceValue) field.getValue().orElseThrow(NoSuchElementException::new))
                    .setValue(value)
            );
        }
        
        if (model instanceof HasJavadoc) {
            @SuppressWarnings("unchecked")
            final HasJavadoc<?> casted = (HasJavadoc<?>) model;
            casted.getJavadoc().ifPresent(javadoc -> {
                final List<String> rows = Stream.of(javadoc.getText()
                    .split(Formatting.nl())
                ).collect(toList());
                
                Formatting.alignTabs(rows);
                
                javadoc.setText(rows.stream().collect(joining(Formatting.nl())));
            });
        }
    
<no_super_class>