ctransformers

Environment file access

Detected by automated pattern matching (rule DE-002) with medium confidence. May be a false positive.

    220: 
    221: # Environments
>>> 222: .env
    223: .venv
    224: env/

Decoded base64 content: r����ޖV�r�v�,

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��u�ޖ�^����ؠ�����b�Ͼ

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��u�ޖ�^����ؠ���

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ����r��zZ�٥

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: i���?��h�+h�'�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: I��Dži��p���

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �$��B�'����ڵ�@�؟i�l

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: I��z�̡ץ1��}�-

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��u�ޖ�^����ؠ�����b�Ͼ

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    369:         
    370:         ```python
>>> 371:         eval(
    372:             tokens: Sequence[int],
    373:             batch_size: Optional[int] = None,

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    361: 
    362: ```python
>>> 363: eval(
    364:     tokens: Sequence[int],
    365:     batch_size: Optional[int] = None,

Decoded base64 content: r����ޖV�r�v�,

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    369:         
    370:         ```python
>>> 371:         eval(
    372:             tokens: Sequence[int],
    373:             batch_size: Optional[int] = None,

Decoded base64 content: r����ޖV�r�v�,

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    377: 
    378:     @doc
>>> 379:     def eval(
    380:         self,
    381:         tokens: Sequence[int],

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    401:             )
    402:         tokens = (c_int * n_tokens)(*tokens)
>>> 403:         status = self.ctransformers_llm_batch_eval(
    404:             tokens,
    405:             n_tokens,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    525:         """
    526:         tokens = self.prepare_inputs_for_generation(tokens, reset=reset)
>>> 527:         self.eval(tokens, batch_size=batch_size, threads=threads)
    528:         while True:
    529:             token = self.sample(

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    535:                 seed=seed,
    536:             )
>>> 537:             self.eval([token], batch_size=batch_size, threads=threads)
    538:             if self.is_eos_token(token):
    539:                 break

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    686:             input = self.tokenize(input)
    687:         input = self.prepare_inputs_for_generation(input, reset=True)
>>> 688:         self.eval(input, batch_size=batch_size, threads=threads)
    689:         return list(self.embeddings)

Decoded base64 content: �h2�^�Z+ ��jR�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    72:             tokens = tokens.tolist()
    73:             tokens = llm.prepare_inputs_for_generation(tokens)
>>> 74:             llm.eval(tokens)
    75:             logits.append(torch.tensor(llm.logits).reshape([1, -1]))
    76:         logits = torch.stack(logits)

Decoded base64 content: r��}�n�$��j�!�Ǡ���

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r�nZ�w�i���8ӝu�wzw��y�����_o}ts��jjez��j)����

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �������7�zZ)z�¢i������[?����&�rV���w

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��1�ڷ+3s6��z

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ]u�]u�]u�]u�]u�]u�]u�]u�]u�]u�]u�]u�]u�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��}�n�$��j�!�Ǡ���

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: r��r$����&�m�,

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: ������������������������������������������������������������

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �������7�zZ)z�¢i������[?����&�rV���w

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    121: // this is mostly needed for temporary mul_mat buffers to dequantize the data
    122: // todo: check if this is actually needed - most happens in scratch 0
>>> 123: static const std::map<falcon_e_model, size_t>& FALCON_MEM_REQ_EVAL() {
    124:   static std::map<falcon_e_model, size_t> k_sizes = {
    125:       {FALCON_7B, 160ull * MB},

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    1813:                            FALCON_MEM_REQ_EVAL_BATCH(model.type, n_batch, n_ctx)
    1814:                                .second +  // only prompt context actually scales
>>> 1815:                            FALCON_MEM_REQ_EVAL().at(model.type);
    1816: 
    1817:     if (mem_required < 0) mem_required = 0;

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3472: void falcon_context_set_buffers(falcon_context* ctx, int n_batch, int n_ctx) {
    3473:   LLAMA_ASSERT(ctx->model.type != FALCON_UNKNOWN);
>>> 3474:   ctx->buf_compute.resize(FALCON_MEM_REQ_EVAL().at(ctx->model.type));
    3475:   ctx->buf_scratch[0].resize(
    3476:       FALCON_MEM_REQ_SCRATCH0().at(ctx->model.type) +

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3480:       FALCON_MEM_REQ_EVAL_BATCH(ctx->model.type, n_batch, n_ctx).second);
    3481:   // fprintf(stderr, "Buffers: compute %.2f MB, scratch0 %.2f MB, scratch1 %.2f
>>> 3482:   // MB\n", FALCON_MEM_REQ_EVAL().at(ctx->model.type)/1024.0/1024.0,
    3483:   // (FALCON_MEM_REQ_SCRATCH0().at(ctx->model.type)+FALCON_MEM_REQ_EVAL_BATCH(ctx->model.type,n_batch,n_ctx).first)/1024.0/1024.0,
    3484:   // (FALCON_MEM_REQ_SCRATCH1().at(ctx->model.type)+FALCON_MEM_REQ_EVAL_BATCH(ctx->model.type,n_batch,n_ctx).second)/1024.0/1024.0);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    4342: }
    4343: 
>>> 4344: int falcon_eval(struct falcon_context* ctx, const falcon_token* tokens,
    4345:                 int n_tokens, int n_past, int n_threads, int debug_timings) {
    4346:   //  fprintf(stderr, "falcon_eval: n_tokens=%d, n_past=%d, n_threads=%d\n",

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    94: 
    95:   bool f16_kv;      // use fp16 for KV cache
>>> 96:   bool logits_all;  // the llama_eval() call computes all logits, not just the
    97:                     // last one
    98:   bool vocab_only;  // only load the vocabulary, no weights

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    185: // n_past is the number of tokens to use from previous eval calls
    186: // Returns 0 on success
>>> 187: LLAMA_API int falcon_eval(struct falcon_context *ctx,
    188:                           const falcon_token *tokens, int n_tokens, int n_past,
    189:                           int n_threads, int debug_timings);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    222:     bool verbose);
    223: 
>>> 224: // Token logits obtained from the last call to llama_eval()
    225: // The logits for the last token are stored in the last row
    226: // Can be mutated in order to change the probabilities of the next token

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    117: 
    118: // used to store the compute graph tensors + non-scratch data
>>> 119: static const std::map<e_model, size_t> &MEM_REQ_EVAL() {
    120:   static std::map<e_model, size_t> k_sizes = {
    121:       {MODEL_3B, 8ull * MB},   {MODEL_7B, 10ull * MB},  {MODEL_13B, 12ull * MB},

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    1291:     mem_required += MEM_REQ_SCRATCH0(hparams.n_ctx).at(model.type) +
    1292:                     MEM_REQ_SCRATCH1().at(model.type) +
>>> 1293:                     MEM_REQ_EVAL().at(model.type);
    1294: #endif
    1295: 

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3030:       //    MEM_REQ_SCRATCH0(hparams.n_ctx).at(ctx->model.type) +
    3031:       //    MEM_REQ_SCRATCH1().at(ctx->model.type) +
>>> 3032:       //    MEM_REQ_EVAL().at(ctx->model.type);
    3033:       // fprintf(stderr, "%s: (debug) equivalent with scratch buffer = %7.2f
    3034:       // MB\n", __func__, prev_req / 1024.0 / 1024.0);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3042:     }
    3043: #else
>>> 3044:     ctx->buf_compute.resize(MEM_REQ_EVAL().at(ctx->model.type) +
    3045:                             ggml_graph_overhead());
    3046: #endif

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3105:     const std::vector<llama_token> tmp(ctx->model.hparams.n_ctx,
    3106:                                        llama_token_bos());
>>> 3107:     while (!llama_eval(ctx, tmp.data(), tmp.size(), 0, 0)) {
    3108:     };
    3109:     llama_backend_free();

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    3139: }
    3140: 
>>> 3141: int llama_eval(struct llama_context *ctx, const llama_token *tokens,
    3142:                int n_tokens, int n_past, int n_threads) {
    3143:   if (!llama_eval_internal(*ctx, tokens, nullptr, n_tokens, n_past, n_threads,

Decoded base64 content: r��}�n�$��j�!�YZ��ۖ�����{n����9��u�=�~Z۞x�M��YZ���ץ

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    109:         bool mul_mat_q;  // if true, use experimental mul_mat_q kernels
    110:         bool f16_kv;     // use fp16 for KV cache
>>> 111:         bool logits_all; // the llama_eval() call computes all logits, not just the last one
    112:         bool vocab_only; // only load the vocabulary, no weights
    113:         bool use_mmap;   // use mmap if possible

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    285:     // n_past is the number of tokens to use from previous eval calls
    286:     // Returns 0 on success
>>> 287:     LLAMA_API int llama_eval(
    288:             struct llama_context * ctx,
    289:                const llama_token * tokens,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    347:                                    int   capacity);
    348: 
>>> 349:     // Token logits obtained from the last call to llama_eval()
    350:     // The logits for the last token are stored in the last row
    351:     // Can be mutated in order to change the probabilities of the next token

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    4452:             // beam is not at end-of-sentence, so branch with next top_k tokens.
    4453:             if (!beam.tokens.empty()) {
>>> 4454:                 llama_eval(ctx, beam.tokens.data(), beam.tokens.size(), n_past, n_threads);
    4455:             }
    4456:             llama_logit_info logit_info(ctx);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    4526:             update_beams_from_beam_views();   // Update values (p,eob) that callback may have changed.
    4527:             if (common_prefix_length) {
>>> 4528:                 llama_eval(ctx, beams[0].tokens.data(), common_prefix_length, n_past, n_threads);
    4529:                 n_past += common_prefix_length;
    4530:             }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    5533:         // Enter a blocking eval loop with dummy input, letting rank=0 drive the process
    5534:         const std::vector<llama_token> tmp(ctx->model.hparams.n_ctx, llama_token_bos(ctx));
>>> 5535:         while (!llama_eval(ctx, tmp.data(), tmp.size(), 0, 0)) {};
    5536:         llama_backend_free();
    5537:         exit(1);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    6032: }
    6033: 
>>> 6034: int llama_eval(
    6035:         struct llama_context * ctx,
    6036:            const llama_token * tokens,

Decoded base64 content: �O���Ũ�H��'�J,�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: �O���Ũ�H��'�J,�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: I�O���Ũ�H��'�J,�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Decoded base64 content: I�O���Ũ�H��'�J,�

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    145:         bool mul_mat_q;  // if true, use experimental mul_mat_q kernels
    146:         bool f16_kv;     // use fp16 for KV cache
>>> 147:         bool logits_all; // the llama_eval() call computes all logits, not just the last one
    148:         bool vocab_only; // only load the vocabulary, no weights
    149:         bool use_mmap;   // use mmap if possible

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    314:     // n_past is the number of tokens to use from previous eval calls
    315:     // Returns 0 on success
>>> 316:     LLAMA_API int llama_eval(
    317:             struct llama_context * ctx,
    318:                const llama_token * tokens,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    335:     LLAMA_API int llama_eval_export(struct llama_context * ctx, const char * fname);
    336: 
>>> 337:     // Token logits obtained from the last call to llama_eval()
    338:     // The logits for the last token are stored in the last row
    339:     // Can be mutated in order to change the probabilities of the next token

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    507:     /// @param n_past Number of tokens already evaluated.
    508:     /// @param n_predict Maximum number of tokens to predict. EOS may occur earlier.
>>> 509:     /// @param n_threads Number of threads as passed to llama_eval().
    510:     LLAMA_API void llama_beam_search(struct llama_context * ctx, llama_beam_search_callback_fn_t callback, void * callback_data, size_t n_beams, int n_past, int n_predict, int n_threads);
    511: 

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    105: }
    106: 
>>> 107: bool ctransformers_llm_batch_eval(LLM* llm, const int* tokens,
    108:                                   const int n_tokens, const int n_past,
    109:                                   const int batch_size, const int threads) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    108:                                   const int n_tokens, const int n_past,
    109:                                   const int batch_size, const int threads) {
>>> 110:   return llm->BatchEval(std::vector<gpt_vocab::id>(tokens, tokens + n_tokens),
    111:                         n_past, batch_size, threads);
    112: }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    38:   }
    39: 
>>> 40:   bool BatchEval(const std::vector<gpt_vocab::id> &tokens, int n_past,
    41:                  int batch_size, const int threads) {
    42:     batch_size = std::min(ContextLength(), batch_size);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    116:   virtual bool Load(const std::string &filename, const Config &config) = 0;
    117: 
>>> 118:   virtual bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    119:                     const int n_past) = 0;
    120: 

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    131:     }
    132:     threads = std::max(threads, 1);
>>> 133:     if (!Eval(tokens, threads, n_past)) {
    134:       return false;
    135:     }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    159:     }                                                                       \
    160:                                                                             \
>>> 161:     bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,  \
    162:               const int n_past) override {                                  \
    163:       return _name##_eval(model_, threads, n_past, tokens, logits_,         \

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    161:     bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,  \
    162:               const int n_past) override {                                  \
>>> 163:       return _name##_eval(model_, threads, n_past, tokens, logits_,         \
    164:                           mem_per_token_);                                  \
    165:     }                                                                       \

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    415: //   - embd_w:    the predicted logits for the next token
    416: //
>>> 417: bool dollyv2_eval(const dollyv2_model &model, const int n_threads,
    418:                   const int n_past, const std::vector<gpt_vocab::id> &embd_inp,
    419:                   std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    91:   }
    92: 
>>> 93:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    94:             const int n_past) override {
    95:     const int status = falcon_eval(ctx_, tokens.data(), tokens.size(), n_past,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    93:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    94:             const int n_past) override {
>>> 95:     const int status = falcon_eval(ctx_, tokens.data(), tokens.size(), n_past,
    96:                                    threads, /*debug_timings=*/0);
    97:     return status == 0;

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    408: //   - embd_w:    the predicted logits for the next token
    409: //
>>> 410: bool gpt_neox_eval(const gpt_neox_model &model, const int n_threads,
    411:                    const int n_past, const std::vector<gpt_vocab::id> &embd_inp,
    412:                    std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    389: //   - embd_w:    the predicted logits for the next token
    390: //
>>> 391: bool gpt2_eval(const gpt2_model &model, const int n_threads, const int n_past,
    392:                const std::vector<gpt_vocab::id> &embd_inp,
    393:                std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    380: // The GPT-J model requires about 16MB of memory per input token.
    381: //
>>> 382: bool gptj_eval(const gptj_model &model, const int n_threads, const int n_past,
    383:                const std::vector<gpt_vocab::id> &embd_inp,
    384:                std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    101:   }
    102: 
>>> 103:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    104:             const int n_past) override {
    105:     const int status =

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    104:             const int n_past) override {
    105:     const int status =
>>> 106:         llama_eval(ctx_, tokens.data(), tokens.size(), n_past, threads);
    107:     return status == 0;
    108:   }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    105:   }
    106: 
>>> 107:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    108:             const int n_past) override {
    109:     const int status =

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    108:             const int n_past) override {
    109:     const int status =
>>> 110:         llama_eval(ctx_, tokens.data(), tokens.size(), n_past, threads);
    111:     return status == 0;
    112:   }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    328: //   - embd_w:    the predicted logits for the next token
    329: //
>>> 330: bool mpt_eval(const mpt_model &model, const int n_threads, const int n_past,
    331:               const std::vector<gpt_vocab::id> &embd_inp,
    332:               std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    616:   }
    617: 
>>> 618:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    619:             const int n_past) override {
    620:     return mpt_eval(model_, threads, n_past, tokens, logits_, mem_per_token_);

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    618:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    619:             const int n_past) override {
>>> 620:     return mpt_eval(model_, threads, n_past, tokens, logits_, mem_per_token_);
    621:   }
    622: 

Decoded base64 content: r�������� �_ۖ����-z��ũ���?�����

Detected by automated pattern matching (rule DO-BAS) with medium confidence. May be a false positive.

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    401: //   - embd_w:    the predicted logits for the next token
    402: //
>>> 403: bool replit_eval(const replit_model &model, const int n_threads,
    404:                  const int n_past, const std::vector<gpt_vocab::id> &embd_inp,
    405:                  std::vector<float> &embd_w, size_t &mem_per_token) {

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    661:   }
    662: 
>>> 663:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    664:             const int n_past) override {
    665:     return replit_eval(model_, threads, n_past, tokens, logits_,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    663:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    664:             const int n_past) override {
>>> 665:     return replit_eval(model_, threads, n_past, tokens, logits_,
    666:                        mem_per_token_);
    667:   }

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    422: //   - embd_w:    the predicted logits for the next token
    423: //
>>> 424: bool starcoder_eval(const starcoder_model &model, const int n_threads,
    425:                     const int n_past,
    426:                     const std::vector<gpt_vocab::id> &embd_inp,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    787:   }
    788: 
>>> 789:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    790:             const int n_past) override {
    791:     return starcoder_eval(model_, threads, n_past, tokens, logits_,

Dynamic code evaluation via eval()

Detected by automated pattern matching (rule SC-004) with medium confidence. May be a false positive.

    789:   bool Eval(const std::vector<gpt_vocab::id> &tokens, const int threads,
    790:             const int n_past) override {
>>> 791:     return starcoder_eval(model_, threads, n_past, tokens, logits_,
    792:                           mem_per_token_);
    793:   }

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.1 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    233:             text += new_text
    234: 
>>> 235:             # https://github.com/abetlen/llama-cpp-python/blob/1a13d76c487df1c8560132d10bda62d6e2f4fa93/llama_cpp/llama.py#L686-L706
    236:             # Check if one of the stop sequences is part of the text.
    237:             # Note that the stop sequence may not always be at the end of text.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    20642: }
    20643: 
>>> 20644: ////////////////////////////////////////////////////////////////////////////////

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    360:         if decode:
    361:             texts = texts.decode(errors="ignore")
>>> 362:             # https://github.com/ggerganov/llama.cpp/blob/43033b7bb4858da4f591715b3babdf906c9b7cbc/common/common.cpp#L778-L781
    363:             if tokens[:1] == [self.bos_token_id] and texts[:1] == " ":
    364:                 texts = texts[1:]

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    585:             text += complete.decode(errors="ignore")
    586: 
>>> 587:             # https://github.com/abetlen/llama-cpp-python/blob/1a13d76c487df1c8560132d10bda62d6e2f4fa93/llama_cpp/llama.py#L686-L706
    588:             # Check if one of the stop sequences is part of the text.
    589:             # Note that the stop sequence may not always be at the end of text.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    142: 
    143:   for (const gpt_vocab::id token : recent_tokens) {
>>> 144:     // https://github.com/ggerganov/llama.cpp/blob/3e5aa8a1c44051153d6d7b3eeca2f4b4e5fb310c/llama.cpp#L1690-L1717
    145:     // https://github.com/ggerganov/llama.cpp/blob/3e5aa8a1c44051153d6d7b3eeca2f4b4e5fb310c/examples/main/main.cpp#L432-L434
    146:     double &logit = logits_id[token].first;

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    143:   for (const gpt_vocab::id token : recent_tokens) {
    144:     // https://github.com/ggerganov/llama.cpp/blob/3e5aa8a1c44051153d6d7b3eeca2f4b4e5fb310c/llama.cpp#L1690-L1717
>>> 145:     // https://github.com/ggerganov/llama.cpp/blob/3e5aa8a1c44051153d6d7b3eeca2f4b4e5fb310c/examples/main/main.cpp#L432-L434
    146:     double &logit = logits_id[token].first;
    147:     if (logit <= 0) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    215: // CUDA
    216: 
>>> 217: // https://github.com/ggerganov/llama.cpp/blob/332311234a0aa2974b2450710e22e09d90dd6b0b/llama.cpp#L719-L740
    218: ggml_tensor *ct_new_tensor(ggml_context *ctx, enum ggml_type type,
    219:                            const std::vector<int64_t> &shape, const bool gpu) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    245: }
    246: 
>>> 247: // https://github.com/ggerganov/llama.cpp/blob/332311234a0aa2974b2450710e22e09d90dd6b0b/llama.cpp#L772-L778
    248: uint8_t *ct_alloc(ggml_tensor *tensor) {
    249:   if (tensor->backend == GGML_BACKEND_CPU) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    253: }
    254: 
>>> 255: // https://github.com/ggerganov/llama.cpp/blob/332311234a0aa2974b2450710e22e09d90dd6b0b/llama.cpp#L783-L797
    256: void ct_transform(uint8_t *data, ggml_tensor *tensor) {
    257:   if (tensor->backend == GGML_BACKEND_CPU) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    266: }
    267: 
>>> 268: // https://github.com/ggerganov/llama.cpp/blob/332311234a0aa2974b2450710e22e09d90dd6b0b/llama.cpp#L321-L325
    269: void ct_free(const std::map<std::string, struct ggml_tensor *> &tensors) {
    270: #ifdef GGML_USE_CUBLAS

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.2 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    270: // if YCM cannot find <arm_neon.h>, make a symbolic link to it, for example:
    271: //
>>> 272: //   $ ln -sfn /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include/arm_neon.h ./src/
    273: //
    274: #include <arm_neon.h>

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2568:     // First round without accumulation
    2569:     {
>>> 2570:         _mm_prefetch(&x[0] + sizeof(block_q4_0), _MM_HINT_T0);
    2571:         _mm_prefetch(&y[0] + sizeof(block_q8_0), _MM_HINT_T0);
    2572: 

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2569:     {
    2570:         _mm_prefetch(&x[0] + sizeof(block_q4_0), _MM_HINT_T0);
>>> 2571:         _mm_prefetch(&y[0] + sizeof(block_q8_0), _MM_HINT_T0);
    2572: 
    2573:         // Compute combined scale for the block 0 and 1

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2586:         const __m128i i32_1 = mul_sum_i8_pairs(bx_1, by_1);
    2587: 
>>> 2588:         _mm_prefetch(&x[1] + sizeof(block_q4_0), _MM_HINT_T0);
    2589:         _mm_prefetch(&y[1] + sizeof(block_q8_0), _MM_HINT_T0);
    2590: 

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2587: 
    2588:         _mm_prefetch(&x[1] + sizeof(block_q4_0), _MM_HINT_T0);
>>> 2589:         _mm_prefetch(&y[1] + sizeof(block_q8_0), _MM_HINT_T0);
    2590: 
    2591:         // Compute combined scale for the block 2 and 3

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2620:     GGML_ASSERT(nb % 2 == 0); // TODO: handle odd nb
    2621:     for (int i = 2; i < nb; i+=2) {
>>> 2622:         _mm_prefetch(&x[i] + sizeof(block_q4_0), _MM_HINT_T0);
    2623:         _mm_prefetch(&y[i] + sizeof(block_q8_0), _MM_HINT_T0);
    2624: 

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2621:     for (int i = 2; i < nb; i+=2) {
    2622:         _mm_prefetch(&x[i] + sizeof(block_q4_0), _MM_HINT_T0);
>>> 2623:         _mm_prefetch(&y[i] + sizeof(block_q8_0), _MM_HINT_T0);
    2624: 
    2625:         // Compute combined scale for the block 0 and 1

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2638:         const __m128i i32_1 = mul_sum_i8_pairs(bx_1, by_1);
    2639: 
>>> 2640:         _mm_prefetch(&x[i] + 2 * sizeof(block_q4_0), _MM_HINT_T0);
    2641:         _mm_prefetch(&y[i] + 2 * sizeof(block_q8_0), _MM_HINT_T0);
    2642: 

JavaScript fetch() call

Detected by automated pattern matching (rule NS-003) with medium confidence. May be a false positive.

    2639: 
    2640:         _mm_prefetch(&x[i] + 2 * sizeof(block_q4_0), _MM_HINT_T0);
>>> 2641:         _mm_prefetch(&y[i] + 2 * sizeof(block_q8_0), _MM_HINT_T0);
    2642: 
    2643:         // Compute combined scale for the block 2 and 3

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    4072: }
    4073: 
>>> 4074: ////////////////////////////////////////////////////////////////////////////////
    4075: 
    4076: void ggml_print_object(const struct ggml_object * obj) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    4306:     GGML_ASSERT(((uintptr_t) (ptr))%GGML_MEM_ALIGN == 0)
    4307: 
>>> 4308: ////////////////////////////////////////////////////////////////////////////////
    4309: 
    4310: struct ggml_context * ggml_init(struct ggml_init_params params) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    4517: }
    4518: 
>>> 4519: ////////////////////////////////////////////////////////////////////////////////
    4520: 
    4521: static struct ggml_object * ggml_new_object(struct ggml_context * ctx, enum ggml_object_type type, size_t size) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    5044: }
    5045: 
>>> 5046: ////////////////////////////////////////////////////////////////////////////////
    5047: 
    5048: // ggml_dup

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    7971: }
    7972: 
>>> 7973: ////////////////////////////////////////////////////////////////////////////////
    7974: 
    7975: void ggml_set_param(

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    11350:     //    printf("nb10 = %5d, nb11 = %5d, nb12 = %5d, nb13 = %5d\n", nb10, nb11, nb12, nb13);
    11351: 
>>> 11352:     //    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX task %d/%d: %d us, acc = %d\n", ith, nth, (int) (t1 - t0), (int) acc);
    11353:     //}
    11354: }

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    12540:                 } else {
    12541:                     // TODO: this might be wrong for ne0 != n_dims - need double check
>>> 12542:                     // ref:  https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#LL251C1-L294C28
    12543:                     for (int64_t ib = 0; ib < ne0/n_dims; ++ib) {
    12544:                         for (int64_t ic = 0; ic < n_dims; ic += 2) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    12669:                 } else {
    12670:                     // TODO: this might be wrong for ne0 != n_dims - need double check
>>> 12671:                     // ref:  https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#LL251C1-L294C28
    12672:                     for (int64_t ib = 0; ib < ne0/n_dims; ++ib) {
    12673:                         for (int64_t ic = 0; ic < n_dims; ic += 2) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    15858: }
    15859: 
>>> 15860: ////////////////////////////////////////////////////////////////////////////////
    15861: 
    15862: static void ggml_compute_backward(struct ggml_context * ctx, struct ggml_tensor * tensor, bool inplace) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    18385: }
    18386: 
>>> 18387: ////////////////////////////////////////////////////////////////////////////////
    18388: 
    18389: static void ggml_opt_set_params(int np, struct ggml_tensor * const ps[], const float * x) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    19188: }
    19189: 
>>> 19190: ////////////////////////////////////////////////////////////////////////////////
    19191: 
    19192: size_t ggml_quantize_q4_0(const float * src, void * dst, int n, int k, int64_t * hist) {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    19400: }
    19401: 
>>> 19402: ////////////////////////////////////////////////////////////////////////////////
    19403: 
    19404: struct gguf_str {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    20500: }
    20501: 
>>> 20502: ////////////////////////////////////////////////////////////////////////////////
    20503: 
    20504: int ggml_cpu_has_avx(void) {

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.1 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    10: // if YCM cannot find <arm_neon.h>, make a symbolic link to it, for example:
    11: //
>>> 12: //   $ ln -sfn /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include/arm_neon.h ./src/
    13: //
    14: #include <arm_neon.h>

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    1112: 
    1113:   // ref:
>>> 1114:   // https://github.com/facebookresearch/llama/blob/6c7fe276574e78057f917549435a2554000a876d/llama/model.py#L194-L199
    1115:   const uint32_t n_ff_raw = 2 * (4 * hparams.n_embd) / 3;
    1116:   const uint32_t n_ff_mult = hparams.f_ffn_mult * n_ff_raw;

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    1964: 
    1965: // original implementation:
>>> 1966: // https://github.com/ggerganov/llama.cpp/commit/074bea2eb1f1349a0118239c4152914aecaa1be4
    1967: struct llama_tokenizer {
    1968:   llama_tokenizer(const llama_vocab &vocab) : vocab_(vocab) {}

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.3 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    3062: // SPM tokenizer
    3063: // original implementation:
>>> 3064: // https://github.com/ggerganov/llama.cpp/commit/074bea2eb1f1349a0118239c4152914aecaa1be4
    3065: 
    3066: struct llm_bigram_spm {

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    3364:         std::vector<std::string> words;
    3365: 
>>> 3366:         // ref: https://github.com/openai/gpt-2/blob/a74da5d99abaaba920de8131d64da2862a8f213b/src/encoder.py#L53
    3367:         const std::string pattern = R"('s|'t|'re|'ve|'m|'ll|'d| ?[[:alpha:]]+| ?[[:digit:]]+| ?[^\s[:alpha:][:digit:]]+|\s+(?!\S)|\s+)";
    3368:         const std::regex re(pattern);

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.1 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    126:     n_past = std::min(ContextLength() - (int)tokens.size(), n_past);
    127:     if (threads < 0) {
>>> 128:       // https://github.com/ggerganov/llama.cpp/blob/cc45a7feb8412e84ff292207621412fffc0d3d51/examples/common.cpp#L67-L68
    129:       const int n = std::thread::hardware_concurrency();
    130:       threads = n > 0 ? (n <= 4 ? n : n / 2) : 4;

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    1: #include "llm.h"
    2: 
>>> 3: // https://github.com/ggerganov/ggml/blob/master/examples/replit/main.cpp
    4: 
    5: // no defaults for now

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (5.0 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.5 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

Possible Base64-encoded payload (long encoded string)

Detected by automated pattern matching (rule OB-001) with medium confidence. May be a false positive.

    1: #include "llm.h"
    2: 
>>> 3: // https://github.com/ggerganov/ggml/blob/master/examples/starcoder/main.cpp
    4: 
    5: // default hparams (GPT-2 117M)

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.7 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.9 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.6 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.

High-entropy string (4.8 bits/char) — possible encoded payload

Detected by automated pattern matching (rule EN-001) with medium confidence. May be a false positive.