Esse desafio, se você o aceitar, é escrever três funções ou programas A, B e C:

• A é um quine que gera todos os A, B e C (que também é todo o conteúdo do código em sua submissão).
• B pega um parâmetro F e verifica se é um quine (emitindo FBC) ou se está fazendo algo diferente.
• C pega um parâmetro G e verifica se G possivelmente funciona como B (verificando se F gera FGC). É impossível decidir se uma função é um verificador quine, então vamos fazer algo mais simples:
  • Ele deve retornar verdadeiramente se G é válido para B.
  • Ele deve retornar falsey se G retornar falsey para todos os códigos válidos ou G retornar verdade para todos os códigos não válidos.
  • Pode retornar qualquer coisa, travar ou não terminar, etc, se for um dos outros casos.

Observe que B é possível. A e F não possuem nenhuma entrada; portanto, você pode executá-las e verificar o resultado.

Regras

• Deve haver alguma maneira de saber quais partes são A, B e C da saída de A. Por exemplo: cada uma possui uma linha ou são reconhecidas como três funções no intérprete.
• Cada função deve ser executada apenas com a definição de si mesma, não com seu código completo.
• Você pode usar uma função / programa ou seu código-fonte ou um par de ambos como entrada de B (ou G) e C.
• Você pode redefinir truthy / falsey para um subconjunto desses valores. Você também pode exigir F constantemente retornando algum tipo que você escolher, como uma única sequência.
• Você pode solicitar A, B, F e G, se eles forem chamados com parâmetros válidos, consistentemente não terão alguns tipos de outras entradas ou efeitos colaterais que você escolher, como acessar variáveis ​​globais ou ler stdin, etc.
• Você também pode assumir que F e G, se forem chamados com parâmetros válidos, sempre terminam.
• F deve funcionar na mesma condição que A. Portanto, não pode depender da existência de B ou C ou de outra variável, a menos que essa variável seja definida em sua própria parte em sua saída.
• Nenhuma função ou programa pode ler seu próprio código-fonte.
• Este é o código-golfe, o código mais curto (que é a saída de A) em bytes vence.

CJam, 254 bytes

Um exemplo de resposta, não jogado.

{{['{\"_~}{{[1$'{@\"_~}"{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}_``1>W<"\"]s\~=}_~}"@]s}_~}{{[1$'{@"_~}{{[\"_~}\"2$+'{@\"_~}\"]s`\"{{['{\\\\\"\+\"]s}_~}\"+~1$~{L}@~!&}_~}"]s\~=}_~}{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}

As 3 funções são:

{{['{\"_~}{{[1$'{@\"_~}"{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}_``1>W<"\"]s\~=}_~}"@]s}_~}

{{[1$'{@"_~}{{[\"_~}\"2$+'{@\"_~}\"]s`\"{{['{\\\\\"\+\"]s}_~}\"+~1$~{L}@~!&}_~}"]s\~=}_~}

{{["_~}"2$+'{@"_~}"]s`"{{['{\\"\+"]s}_~}"+~1$~{L}@~!&}_~}

A e F não aceitam parâmetros e retornam uma string. B, G e C tomam um bloco CJam como parâmetro e retornam 1 para verdade ou 0 para falsey.