README.md

---
base_model: [meta-llama/Meta-Llama-3-70B-Instruct]
merge_model: [NousResearch/Hermes-2-Pro-Llama-3-70B]

library_name: transformers
tags:
- mergekit
- merge
license: llama3
---
### Yoloing this 99-layer llamastein straight to the leaderboard wish me luck

> [!TIP]
>for 1bit quant download:
>
```bash
wget https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_1bit_optimized_IQ1_L.gguf
```

for fun use i recommend this file:
```verilog
wget https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_OPTIMAL_IQ_4_XS.gguf
```
if you're on linux you can download much faster with aria2 

```verilog
sudo apt install aria2
aria2c -x 8 -o llamagnific_OPTIMAL_IQ_4_XS.gguf https://huggingface.co/nisten/llamagnific-3-87b-gguf/resolve/main/llamagnific_OPTIMAL_IQ_4_XS.gguf
```
make a prompt file named prompt.txt and put this in it 

```verilog
<|im_start|>system{You are a hyperintelligent hilarious raccoon that solves everything via first-principles based resoning.}<|im_end|>
<|im_start|>user{Careful this is a trick question. Think first then when done thinking say ...done_thinking... and answer correctly: 9.11 or 9.9, which is greater?}
<|im_end|>assistant
```

That's it that's your prompt template, to run it in conversaion do this (add -ngl 99 or less if you have a 24gb gpu, i.e. add -ngl 50 for a 16gb etc, the model itself is 98 layers so this determines how many layers you offload to gpu, by default its 0 ): 

```c
./llama-cli --temp 0.4 -m llamagnific_OPTIMAL_IQ_4_XS.gguf -fa -co -cnv -i -f prompt.txt
```

![image/png](https://cdn-uploads.huggingface.co/production/uploads/6379683a81c1783a4a2ddba8/K-ZX8HE_ph5eRlieFbEQj.png)


# base_model: [meta-llama/Meta-Llama-3-70B-Instruct]
# merge_model: [NousResearch/Hermes-2-Pro-Llama-3-70B]

This is a merge of pre-trained language models created using [mergekit](https://github.com/cg123/mergekit).

## Merge Details
### Merge Method

This model was merged using the passthrough merge method.

### Models Merged

The following models were included in the merge:
* /home/admin/meta70
* /home/admin/hermes2pro

### Configuration

The following YAML configuration was used to produce this model:

```yaml
dtype: bfloat16
merge_method: passthrough
slices:
- sources:
  - layer_range: [0, 15]
    model: /home/admin/meta70
- sources:
  - layer_range: [10, 69]
    model: /home/admin/hermes2pro
- sources:
  - layer_range: [55, 80]
    model: /home/admin/meta70
```

#TEST PROMPT IS LOOKING INTERESTING
> [!TIP]
> How to build a city on Mars? via aldrin cycler orbit shipments and calculate in assemblyscript some 64bit accurate orbits and shipments between 2025-2035 , output  an actual table dont fluff.
>

```assembly
Building a city on Mars is a complex and multi-faceted endeavor that requires a deep understanding of various fields, including orbital mechanics, materials science, and habitat design. Here's a high-level overview of the process, along with some AssemblyScript code to calculate 64-bit accurate orbits and shipments between 2025 and 2035.

**Step 1: Orbital Mechanics and Aldrin Cycler**

The Aldrin cycler is a type of spacecraft that uses a specific orbit to travel between Earth and Mars, making it an energy-efficient option for transporting people and cargo. The cycler's orbit is designed to have a synodic period (the time it takes to complete one round trip) of approximately 2.14 years, which is close to the Earth-Mars synodic period.

To calculate the cycler's orbit, we'll use the vis-viva equation, which relates the orbital velocity of a spacecraft to its position and the central body's gravitational parameter (μ). The equation is:

v = sqrt(μ \* (2/r - 1/a))

where:
v = orbital velocity
μ = standard gravitational parameter (for Earth, μ = 3.986004418e+14 m³/s²)
r = position vector (distance from the central body)
a = semi-major axis of the orbit

Here's an AssemblyScript function to calculate the cycler's orbit:


(import "env" "console_log" (func $console_log (result i32) (i32)))

(memory (import "env" "memory") 1)

(data (i32.const 0) "\0A\00\00\00")

@; Calculate the cycler's orbit
@; Args: r (f64) - position vector (distance from the central body)
@;        a (f64) - semi-major axis of the orbit
@; Returns: v (f64) - orbital velocity
(func $cycler_orbit (param $r f64) (param $a f64) (result f64)
  (f64.mul
    (f64.const 3.986004418e+14)
    (f64.sub
      (f64.div
        (f64.const 2)
        (f64.copy $r)
      )
      (f64.div
        (f64.const 1)
        (f64.copy $a)
      )
    )
  )
)

@; Example usage: Calculate the cycler's velocity at a position of 1.5 AU
@; (1 AU = 1.496e+11 m) and a semi-major axis of 2.4 AU
(f64.print
  (call $cycler_orbit
    (f64.mul (f64.const 1.5) (f64.const 1.496e+11))
    (f64.mul (f64.const 2.4) (f64.const 1.496e+11)))
  )
)


**Step 2: Assembly and Construction**

Once you've calculated the cycler's orbit, you'll need to assemble and construct the city on Mars. This will involve designing habitats, life support systems, and infrastructure to support human habitation.

**Step 3: Table of Shipments**

To create a table of shipments between 2025 and 2035, you'll need to determine the number of cyclers, the cargo capacity of each cycler, and the frequency of shipments. Here's a simple AssemblyScript function to calculate the total cargo capacity over a given period:


@; Calculate the total cargo capacity over a given period
@; Args: num_cyclers (i64) - number of cyclers
@;        cargo_capacity (f64) - cargo capacity of each cycler (in tons)
@;        start_year (i64) - start year (e.g., 2025)
@;        end_year (i64) - end year (e.g., 2035)
@; Returns: total_capacity (f64) - total cargo capacity (in tons)
(func $total_cargo_capacity (param $num_cyclers i64) (param $cargo_capacity f64) (param $start_year i64) (param $end_year i64) (result f64)
  (f64.mul
    (f64.conv_i64_f64
      (i64.sub
        (get_local $end_year)
        (get_local $start_year)
      )
    )
    (f64.conv_i64_f64
      (get_local $num_cyclers)
    )
    (f64.copy $cargo_capacity)
  )
)

@; Example usage: Calculate the total cargo capacity for 2 cyclers with a capacity of 500 tons each, between 2025 and 2035
(f64.print
  (call $total_cargo_capacity
    (i64.const 2)
    (f64.const 500)
    (i64.const 2025)
    (i64.const 2035)
  )
)


This is a high-level overview of the process, and there are many more details to consider when building a city on Mars. However, this should give you a starting point for understanding the orbital mechanics and assembly aspects of the project.
```