Considere a aplicação desses algoritmos de carregamento com ligação direta ao exemplo apresentado acima. Dois arquivos de módulo objeto são passados como argumentos ao carregador, um para o segmento MAIN e outro para o segmento PGM.
Na fase de alocação de memória, o carregador obtém a informação que o segmento MAIN tem 28 bytes (1C em hexadecimal), enquanto que o segmento PGM tem 18 bytes. Assim, o carregador deve requisitar a alocação de uma área de 46 bytes ao sistema operacional.
Considere que o sistema operacional alocou esta área a partir da posição de memória $1000, que será o valor de ipla. Na fase de criação da GEST, o primeiro registro lido é a definição de MAIN, que receberá o valor de segStart, inicializado com $1000. Assim, o par (MAIN,$1000) é inserido na tabela. A variável segLength receberá o valor $1C. Os demais registros deste módulo, de tipo 1 e 2, são ignorados nesta fase. Quando o último registro é lido, de tipo 3 (END), o valor de segLength é atualizado para $101C.
Quando o segundo módulo é processado neste segundo passo, o primeiro registro é também a definição de um segmento, PGM. O par (PGM,$101C) é então inserido na GEST, sendo segLength atualizado para $12. O segundo registro é a definição de um símbolo local. Neste caso, a variável position recebe o valor $10 e a variável newValue recebe $102C. Assim, a GEST receberá a definição do par (DIGIT,$102C). Como para o primeiro módulo, os demais registros são ignorados, até a leitura do registro do tipo 3. Como não há outros módulos a varrer, o segundo passo é encerrado, com o valor de segStart sendo atualizado para $102E.
Ao final deste passo, a GEST apresentará o seguinte conteúdo:
| Símbolo | Valor |
|---|---|
| MAIN | $1000 |
| PGM | $101C |
| DIGIT | $102C |
No terceiro passo, o valor das variáveis segStart e execPoint são reinicializados para $1000. No processamento do primeiro módulo, o efeito do registro tipo 0 (ESD) é simplesmente atribuir a segLength o valor $1C. Os registros do tipo 1 são então processados, sendo que para o primeiro deles o conteúdo 103900000000, de dimensão 6 bytes, é transferido para a posição $1000+$00 de memória. O segundo registro indica a transferência de 0C00000A (4 bytes) para a posição $1000+$06 de memória, e assim consecutivamente. Ao final destas transferências, a memória apresenta o seguinte conteúdo (em hexadecimal):
| Posição | 00 | 02 | 04 | 06 | 08 | 0A | 0C | 0E |
| $1000 | 1039 | 0000 | 0000 | 0C00 | 000A | 6D02 | 5E00 | 0600 |
| $1010 | 0030 | 13C0 | 0000 | 001A | 4E75 | 0000 |
Os registros do tipo 2 (RLD) são então lidos. O primeiro deles indica que os 4 bytes a partir da posição relativa $02, ou seja, a long word na posição de memória segStart+$02 ou $1002, deve ser atualizada pelo valor do símbolo DIGIT. A pesquisa na GEST indica que este símbolo tem o valor $102C, que somado ao conteúdo anterior da posição ($00000000) resulta em
| Posição | Conteúdo |
| $1002 | 0000 |
| $1004 | 102C |
O segundo registro deste tipo no primeiro segmento indica que 4 bytes na posição relativa $14, ou seja, a long word na posição de memória $1014, deve ser atualizada pelo valor do símbolo MAIN. O conteúdo inicial desta posição é $0000001A, e o valor de MAIN, $1000, é obtido da GEST. Assim, estas posições de memória são atualizadas para
| Posição | Conteúdo |
| $1014 | 0000 |
| $1016 | 101A |
O processamento do primeiro módulo se encerra com a definição da variável EXE para o valor $1000 após a leitura do registro de tipo 3.
Para o segundo módulo, o procedimento se repete, agora com segStart com valor $101C. Após a transferência de código a partir desta posição de memória, o processamento de registros de tipo 2 realizarão ajustes de relocação apenas no código deste segmento -- a long word na posição $101E (segStart+2) receberá o valor $0000102A ($0000000E+PGM) e a long word na posição $1024 (segStart+8) receberá o valor $0000102C ($00000010+segStart).
Deste modo, o conteúdo completo da memória após o processamento do segundo módulo será
| Posição | 00 | 02 | 04 | 06 | 08 | 0A | 0C | 0E |
| $1000 | 1039 | 0000 | 102C | 0C00 | 000A | 6D02 | 5E00 | 0600 |
| $1010 | 0030 | 13C0 | 0000 | 101A | 4E75 | 0000 | 3039 | 0000 |
| $1020 | 102A | 33C0 | 0000 | 102C | 4E75 | 0000 | 0000 |
O carregador encerra seu processamento transferindo o controle (através de instrução JUMP) para a posição execPoint ($1000) de memória.