Create README.md

README.md

@@ -0,0 +1,155 @@
+---
+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
+---
+GGUF Files of nisten/llamagnific-3-87b  - a 99layer llama-3-70b frankenstein
+
+
+![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.
+```