#ifdef FRENCH
    IDS_HELLO, "${HELLO_WORLD_FRENCH}"
    #else
    IDS_HELLO, "${HELLO_WORLD}"
    #endif
}
""")
    ]

    List<SourceFile> getResourceSources() {
        getLibrarySources().subList(1, 2)
    }

 * limitations under the License.
 */

package model

import java.util.LinkedList
import kotlin.math.min

/**
 * Split a list of elements into nearly even sublist. If an element is too large, largeElementSplitFunction will be used to split the large element into several smaller pieces;
 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *

        if (relativePathLength == 0) this else this.parentFile.containingSubprojectFolder(relativePathLength - 1)

    private
    fun Array<String>.subArray(toIndex: Int) = listOf(*this).subList(0, toIndex).toTypedArray()

                    add(entry.value.first())
                }
            }
            add(minimumSupported)
        }.filterNotNull().distinct().sorted()
        return latests.subList(latests.indexOf(minimumSupported), latests.size)
    }

    SampleElements<E> samples = samples();
    List<E> allSampleElements =
        Arrays.asList(samples.e0(), samples.e1(), samples.e2(), samples.e3(), samples.e4());
    return new ArrayList<>(allSampleElements.subList(0, howMany));
  }

  @Override
  public CollectionSize getCollectionSize() {
    return collectionSize;
  }

  @Override
  public Iterable<E> order(List<E> insertionOrder) {

            parts.add(original.substring(startPart, pos));
        }
        DefaultVersion base = null;
        if (endBaseStr > 0) {
            base = new DefaultVersion(original.substring(0, endBaseStr), parts.subList(0, endBase), null);
        }
        return new DefaultVersion(original, parts, base);
    }

    private static class DefaultVersion implements Version {
        private final String source;

            } else if (state == DfsState.VISITING) {
                // we are already visiting this vertex, this mean we have a cycle
                int pos = cycle.lastIndexOf(v.label);
                List<String> ret = cycle.subList(pos, cycle.size());
                ret.add(v.label);
                return ret;
            }
        }
        return null;
    }

    static class Vertex {
        final String label;

        reduceEqualLinesFromHeadAndTail(originalLines, revisedLines, contextSize);
        originalLines = originalLines.subList(offsetHead, originalLines.size() - offsetTail);
        revisedLines = revisedLines.subList(offsetHead, revisedLines.size() - offsetTail);

        original = new int[originalLines.size() + 1];
        revised = new int[revisedLines.size() + 1];

     */
    public boolean matchesNextLines(List<String> lines, int startIndex) {
        String nextLines = numLines == 1
            ? lines.get(startIndex)
            : String.join("\n", lines.subList(startIndex, Math.min(startIndex + numLines, lines.size())));
        return matchesNextLines(nextLines);
    }

    protected abstract boolean matchesNextLines(String nextLines);

                    yieldIfNotNull(element as? KtClassLikeDeclaration)
                    continue
                }

                if (element is KtDeclarationContainer) {
                    val newChunks = chunks.subList(1, chunks.size)
                    for (child in element.declarations) {
                        tasks.addLast(Task(newChunks, child))
                    }
                }
            }
        }
    }