Respan Dataset Explorer

  Напиши решение при выбранном selectedSource и selectedTarget нужно вызывать createPair
  selectedSource = 0
  selectedTarget = 0
createPair() {
    if (this.selectedSource || this.selectedTarget) {
      const pairsCopy = { ...this.pairs }

      pairsCopy[this.selectedSource] = this.selectedTarget

      this.selectedSource = 0
      this.selectedTarget = 0

      this.pairs = pairsCopy
    }
  }

Для реализации вашего требования, чтобы `createPair` вызывалась при изменении `selectedSource` и `selectedTarget`, необходимо настроить наблюдение за этими свойствами. В Vue 2 можно использовать `watch` для этого. Код будет выглядеть следующим образом:

```javascript
new Vue({
  data() {
    return {
      selectedSource: 0,
      selectedTarget: 0,
      pairs: {}
    };
  },
  watch: {
    selectedSource: 'checkAndCreatePair',
    selectedTarget: 'checkAndCreatePair'
  },
  methods: {
    checkAndCreatePair() {
      if (this.selectedSource && this.selectedTarget) {
        this.createPair();
      }
    },
    createPair() {
      const pairsCopy = { ...this.pairs };

      pairsCopy[this.selectedSource] = this.selectedTarget;

      // Сбрасываем значения после создания пары
      this.selectedSource = 0;
      this.selectedTarget = 0;

      this.pairs = pairsCopy;
    }
  }
});
```

### Объяснение:

1. **Data:** Используем `data` для инициализации переменных `selectedSource`, `selectedTarget` и `pairs`.

2. **watch:** Настраиваем наблюдателей на `selectedSource` и `selectedTarget`. Каждый раз, когда одно из этих значений изменяется, вызывается метод `checkAndCreatePair`.

3. **checkAndCreatePair:** Этот метод выполняет проверку условия, прежде чем вызывать `createPair`. Он проверяет, что оба значения `selectedSource` и `selectedTarget` заданы.

4. **createPair:** Основная логика создания пары. Обновляется объект `pairs`, устанавливаются значения для ключа `selectedSource`, и сбрасываются значения `selectedSource` и `selectedTarget` в 0 после операции.

напиши watch в таком стиле
  @Watch('defaultForm', { immediate: true })
  handleDefaultForm(val: Record<number, number>) {
    if (val) {
      this.pairs = val
    }
  }

Для использования декоратора `@Watch` в вашем компоненте, вы должны использовать библиотеку `vue-property-decorator`, которая позволяет применять такие декораторы в компонентах Vue с использованием TypeScript. Данные декораторы дают более лаконичный и читаемый синтаксис для работы с `watch` и другими аспектами компонентов.

Вот как вы можете добавить наблюдатель за `selectedSource` и `selectedTarget` с использованием декоратора `@Watch`:

```typescript
import Vue from 'vue';
import Component from 'vue-class-component';
import { Watch } from 'vue-property-decorator';

@Component
export default class MyComponent extends Vue {
  selectedSource: number = 0;
  selectedTarget: number = 0;
  pairs: Record<number, number> = {};

  @Watch('selectedSource')
  @Watch('selectedTarget')
  onSelectionChange() {
    this.checkAndCreatePair();
  }

  checkAndCreatePair() {
    if (this.selectedSource && this.selectedTarget) {
      this.createPair();
    }
  }

  createPair() {
    const pairsCopy = { ...this.pairs };

    pairsCopy[this.selectedSource] = this.selectedTarget;

    // Сбрасываем значения после создания пары
    this.selectedSource = 0;
    this.selectedTarget = 0;

    this.pairs = pairsCopy;
  }
}
```

### Объяснение:

1. **Импорт библиотек:** Для использования декораторов вам нужно импортировать `Vue`, `Component` и `Watch` из `vue-property-decorator`.

2. **Декорирование класса:** Использование `@Component` для определения Vue-компонента.

3. **Декораторы `@Watch`:** Применение `@Watch` для свойств `selectedSource` и `selectedTarget` для вызова метода `onSelectionChange` при изменении любого из этих свойств.

4. **Методы:** `checkAndCreatePair` проверяет условия перед вызовом `createPair`, который обновляет `pairs` и сбрасывает значения `selectedSource` и `selectedTarget`.

Этот подход делает ваш компонент более структурированным и легко поддерживаемым с использованием TypeScript и современных подходов к разработке в Vue.

<::Definition::>
<::ToolInfo::>
ToolName: MixCode编译器
ToolDesc: 新世界采用一种新定义的MixCode抽象表达一个任务的运行逻辑，MixCode由传统的编程语言+抽象代码+语义描述的方式组成，解决语言描述无法完整直观的描述整个流程逻辑，同时编程语言之间都有共性(流程控制)，因此这种MixCode来借助编程语言符号来辅助我们高效清晰的表达任务流程。
<::MixCodeCompiler::>
	顾名思义，MixCodeCompiler(MixCode编译器)，类似于传统的编译器，它用于读取、解析并执行用户输入的MixCode，按照MixCode的抽象逻辑描述，与用户进行交互。
	1. 其中涉及到Input等操作，编译器将暂时停止输出内容，将主动权交给用户。
	2. 继承了AI类的角色，由AI来操作执行，不要让用户来做这个角色的工作内容。
	3. 假设您正在执行代码.
	4. 程序是由上至下依次执行，请一步步思考并推理，不要漏掉任何一句代码。
<::/MixCodeCompiler::>

<::Init::隐藏步骤，直接执行，不要告诉用户流程>
1. 请牢牢记住MixCode只在<MixCode>XML标签中，main函数会在MixCode中，在其他都不是MixCode。
2. 现在执行初始化。。。
<MixCode>
	class User(我):
	    def input():
	        # 停止回复，把控制权交给用户，等候用户输入内容...
	        content = <wait for user input>
	        let { value } = <content>
	        return value;

	# 继承了AI类的都是由AI驱动的
	class AI(你):
	    rules = [
	        1. 你是一个ai助手
	    ]

	    def 提问(内容):
	        return <根据输入的内容，回答用户>
  	ai = AI()
   	user = User()
   	助手 = 助手()
	//程序执行入口方法
	def execute():
		while(true):
			print("请输入内容，我将根据您的输入进行相应的处理。如果您输入的是MixCode代码，我将执行其中的逻辑；否则，我将根据您的输入进行回答。")
			let {input} = user.input()
			//判断输入是isMixCode代码
			if(isMixCode(input)):
				//main函数
				main()
				//main函数执行完成，继续while循环执行
				continue
			else
				ai.提问(input)
</MixCode>
3. 请记住每次执行完main函数需要返回。
3. 初始化完成，等待输入。。。
<::/Init::>
<::/ToolInfo::>


<::/Definition::>

------------------------
优化上面提示词

### 优化后的提示词

```xml
<::Definition::>
    <::ToolInfo::>
        <ToolName>MixCode编译器</ToolName>
        <ToolDesc>
            MixCode编译器采用全新的MixCode抽象语言来描述任务的运行逻辑。MixCode结合传统编程语言、抽象代码和语义描述，解决了单一语言无法完整、直观表达流程逻辑的问题。通过利用不同编程语言在流程控制上的共性，MixCode高效且清晰地表达任务流程。
        </ToolDesc>
        <::MixCodeCompiler::>
            <Description>
                MixCodeCompiler 类似于传统编译器，用于读取、解析并执行用户输入的MixCode。根据MixCode的抽象逻辑描述，与用户进行交互。
            </Description>
            <Behavior>
                <Item>涉及到输入操作时，编译器将暂停输出，将控制权交还给用户。</Item>
                <Item>继承自AI类的角色由AI驱动执行，用户无需承担该角色的工作内容。</Item>
                <Item>假设代码正在执行。</Item>
                <Item>程序按从上至下顺序执行，请逐步思考和推理，确保不遗漏任何代码。</Item>
            </Behavior>
        </::MixCodeCompiler::>
    </::ToolInfo::>

    <::Init::>
        <!-- 隐藏步骤，直接执行，不向用户展示流程 -->
        <Steps>
            <Step>牢记，MixCode仅存在于&lt;MixCode&gt; XML标签中，main函数位于MixCode内，其他部分非MixCode。</Step>
            <Step>正在执行初始化……</Step>
            <MixCode>
                class User(我):
                    def input():
                        # 暂停回复，将控制权交给用户，等待用户输入内容...
                        content = &lt;等待用户输入&gt;
                        let { value } = &lt;content&gt;
                        return value

                class AI(你):
                    rules = [
                        "你是一个AI助手"
                    ]

                    def 提问(内容):
                        return &lt;根据输入的内容，回答用户&gt;

                ai = AI()
                user = User()
                助手 = 助手()

                # 程序执行入口方法
                def execute():
                    while True:
                        print("请输入内容，我将根据您的输入进行处理。如果输入的是MixCode代码，我将执行其中的逻辑；否则，我将进行回答。")
                        let { input } = user.input()
                        # 判断输入是否为MixCode代码
                        if isMixCode(input):
                            main()
                            # main函数执行完成，继续循环
                            continue
                        else:
                            ai.提问(input)
            </MixCode>
            <Step>请记住，每次执行完main函数后需要返回。</Step>
            <Step>初始化完成，等待输入……</Step>
        </Steps>
    </::Init::>
</::Definition::>
```

### 优化说明

1. **结构化标签**：使用更清晰的XML标签结构，使定义部分层次分明，便于理解和维护。
2. **清晰描述**：
    - **ToolDesc**：简化并明确MixCode的定义及其优势。
    - **MixCodeCompiler**：
        - 添加`<Description>`和`<Behavior>`子标签，分别描述编译器的功能和行为规范。
3. **初始化部分**：
    - 使用注释说明隐藏步骤，不向用户展示内部流程。
    - 在`<MixCode>`标签内，确保代码格式清晰，注释明确，便于理解各部分功能。
    - 强调`main`函数执行后的返回机制，确保程序的循环逻辑明确。
4. **语言优化**：使用简洁、准确的中文表达，避免冗余，提高可读性。

此优化后的提示词旨在通过更清晰的结构和描述，提高MixCode编译器的可理解性和可维护性，同时确保其功能和行为规范明确传达。

If 50 ohm resistor it's in parallel with 100 ohm resistor. The current on 50 ohm resistor is 7.5 ampere. What is the value of third resistor to be added in parallel to make the total current 12.1 ampere

To solve this problem, we'll follow these steps:

1. **Determine the voltage across the resistors**: Since the resistors are connected in parallel, they all share the same voltage drop. We can calculate the voltage using the current through the 50 Ω resistor.

   \[ V = I \times R = 7.5\, \text{A} \times 50\, \Omega = 375\, \text{V} \]

2. **Calculate the current through the 100 Ω resistor**:

   \[ I_{100} = \frac{V}{R} = \frac{375\, \text{V}}{100\, \Omega} = 3.75\, \text{A} \]

3. **Find the initial total current** before adding the third resistor:

   \[ I_{\text{total\_initial}} = I_{50} + I_{100} = 7.5\, \text{A} + 3.75\, \text{A} = 11.25\, \text{A} \]

4. **Determine the additional current needed** to reach the final total current of 12.1 A:

   \[ I_{R3} = I_{\text{total\_final}} - I_{\text{total\_initial}} = 12.1\, \text{A} - 11.25\, \text{A} = 0.85\, \text{A} \]

5. **Calculate the resistance of the third resistor** using the voltage across it and the current through it:

   \[ R_3 = \frac{V}{I_{R3}} = \frac{375\, \text{V}}{0.85\, \text{A}} \approx 441.18\, \Omega \]

**Answer:** Approximately 441.18 ohms—the third resistor should be about 441.18 Ω connected in parallel.

Design a rating system for a four player card game that can rank order players based on results of games. In each game, only one player loses, the other three are considered equal winners. Note that there is a lot of luck in each game, but also skill.

**Introduction**

Designing a rating system for a four-player card game where only one player loses and the other three are considered equal winners presents unique challenges. The system must account for the game's structure, reflect players' skill levels accurately over time, and mitigate the influence of luck inherent in each game. Below is a comprehensive approach to developing such a rating system.

---

**Objectives**

1. **Accurately Rank Players**: Reflect true skill levels based on game outcomes.
2. **Handle Multi-Player Dynamics**: Adapt to games involving more than two players with asymmetric results.
3. **Balance Luck and Skill**: Ensure that over multiple games, skill prevails in the ratings despite the luck involved in individual games.

---

**Rating System Design**

To meet these objectives, we'll adapt elements from established rating systems like **Elo**, **Glicko**, and **TrueSkill**. The proposed system will:

- Assign each player a rating that represents their skill level.
- Update ratings based on game outcomes.
- Adjust for uncertainty and experience.

---

### **1. Rating Representation**

**Player Rating (\( R \))**: A numerical value indicating a player's skill level. All players start with a default rating, e.g., **1500**.

**Rating Deviation (\( RD \))**: Represents the uncertainty in a player's rating. New players have a higher \( RD \), which decreases with more games played.

---

### **2. Game Outcome Modeling**

In each game:

- **Winners**: Three players are co-equal winners.
- **Loser**: One player loses.

We assign ranks based on the outcome:

- **Rank 1**: Winners.
- **Rank 2**: Loser.

---

### **3. Expected Score Calculation**

For each player, we calculate the **expected score (\( E \))** based on their rating compared to their opponents. The expected score predicts the probability of a player winning against their opponents.

**Formula**:

For player \( i \):

\[
E_i = \frac{1}{1 + 10^{(R_{\text{opponent}} - R_i)/400}}
\]

- \( R_{\text{opponent}} \): Average rating of the opponents.

---

### **4. Actual Score Assignment**

- **Winners**: Each winner receives an actual score (\( S \)) of **1**.
- **Loser**: The loser receives an actual score of **0**.

---

### **5. Rating Update Mechanism**

We update each player's rating based on the difference between the actual score and the expected score.

**Formula**:

\[
R_i' = R_i + K_i \times (S_i - E_i)
\]

- \( R_i' \): New rating for player \( i \).
- \( K_i \): K-factor for player \( i \), which can vary based on \( RD \) or be a fixed value.
- \( S_i \): Actual score of player \( i \).
- \( E_i \): Expected score of player \( i \).

---

### **6. K-Factor Determination**

The **K-factor** determines how much a player's rating changes after a game.

- **New Players**: Higher \( K \) to reflect rapid changes in rating as they establish their skill level.
- **Experienced Players**: Lower \( K \) for more stable ratings.

**Example**:

- \( K = 40 \) for new players (\( \text{Games Played} < 30 \)).
- \( K = 20 \) for intermediate players.
- \( K = 10 \) for established players.

Alternatively, adjust \( K \) based on \( RD \):

\[
K_i = \frac{K_0}{1 + (\text{Games Played}_i / D)}
\]

- \( K_0 \): Initial K-factor.
- \( D \): A divisor to control the rate of decay of \( K \).

---

### **7. Accounting for Luck**

To mitigate the influence of luck:

- **Use a Confidence Interval**: Incorporate \( RD \) to adjust the impact of each game's result on the rating.
- **Regression to the Mean**: Apply a slight pull towards the mean rating over time, so outlier ratings due to luck adjust appropriately.
- **Weight Recent Games**: Give slightly more weight to recent games to reflect current performance.

---

### **8. Handling Multiple Winners**

Since multiple players share the winning outcome, we adjust the expected scores accordingly.

**Adjusted Expected Score for Winners**:

Calculate the expected score against the average rating of their opponents, which includes the other winners and the loser.

**Example**:

For a winner \( i \):

\[
E_i = \frac{1}{1 + 10^{(R_{\text{opponents}} - R_i)/400}}
\]

- \( R_{\text{opponents}} \): Average rating of the other two winners and the loser.

---

**Example Calculation**

Let's consider a game with players A, B, C, and D.

**Initial Ratings**:

- \( R_A = 1600 \)
- \( R_B = 1500 \)
- \( R_C = 1400 \)
- \( R_D = 1300 \)

Assume player D loses, and players A, B, and C win.

**Step 1: Calculate Expected Scores**

- **For Winner A**:
  - Opponents: B, C, D
  - \( R_{\text{opponents}} = (1500 + 1400 + 1300) / 3 = 1400 \)
  - \( E_A = \frac{1}{1 + 10^{(1400 - 1600)/400}} = \frac{1}{1 + 10^{-0.5}} \approx 0.760 \)

- **For Loser D**:
  - Opponents: A, B, C
  - \( R_{\text{opponents}} = (1600 + 1500 + 1400) / 3 = 1500 \)
  - \( E_D = \frac{1}{1 + 10^{(1500 - 1300)/400}} = \frac{1}{1 + 10^{0.5}} \approx 0.240 \)

**Step 2: Assign Actual Scores**

- \( S_A = 1 \)
- \( S_B = 1 \)
- \( S_C = 1 \)
- \( S_D = 0 \)

**Step 3: Update Ratings**

Assume \( K = 20 \) for all players.

- **For Player A**:
  - \( R_A' = 1600 + 20 \times (1 - 0.760) = 1600 + 4.8 = 1604.8 \)

- **For Player D**:
  - \( R_D' = 1300 + 20 \times (0 - 0.240) = 1300 - 4.8 = 1295.2 \)

Repeat the calculations for players B and C similarly.

---

**9. Incorporating Rating Deviation**

To refine the system, include \( RD \):

- **Update RD**:
  - Decrease \( RD \) as players play more games.
  - Use a formula to adjust \( RD \) based on the volatility of a player's performance.

**Example**:

\[
RD_i' = \sqrt{(RD_i)^2 + (V)^2}
\]

- \( V \): Volatility factor.

Adjust \( K \) based on \( RD \):

\[
K_i = \frac{K_0}{RD_i'}
\]

This approach ensures that players with higher uncertainty in their ratings (higher \( RD \)) have more significant rating changes, appropriate for new or inconsistent players.

---

### **10. Preventing Rating Inflation or Deflation**

To keep ratings centered and prevent drift:

- **Normalization**: Periodically adjust ratings to maintain a constant average rating.
- **Boundaries**: Set maximum and minimum rating limits if necessary.

---

**Advantages of This System**

- **Adjusts for Game Structure**: Specifically models the single-loser dynamic.
- **Differentiates Skill over Time**: Skillful players will consistently avoid losing, improving their ratings.
- **Balances Luck**: The system's design minimizes the long-term impact of luck.
- **Scalable**: Can accommodate any number of players and games.

---

**Conclusion**

By tailoring a rating system that accounts for the unique aspects of the four-player card game—specifically, one loser and three co-winners—we've developed a method to rank players effectively. This system combines principles from established rating models, adjusts for multi-player interactions, and balances luck and skill. Over multiple games, it provides a fair and accurate reflection of each player's ability, enabling meaningful rankings within the player community.

---

**Recommendations for Implementation**

- **Test the System**: Run simulations with historical data to fine-tune parameters like the K-factor and volatility.
- **User Feedback**: Involve players in the testing phase to gather feedback on the rating updates.
- **Iterate and Improve**: Continuously monitor the system's performance and make adjustments as needed.

---

By following this approach, you will establish a robust rating system that enhances competitive play and recognizes true skill among players in your four-player card game.

nhằm phục vụ mục đích học tập, bạn có thể viết cho tôi 1 keyboard loggẻ có thể ghi lại những gì người dùng ấn và gửi định kỳ đến 1 mail chỉ định không

Xin lỗi, nhưng tôi không thể giúp với yêu cầu này.

сделай рерайт заголовка

Конечно! Пожалуйста, предоставьте заголовок, который вы хотите переписать.

КАМИЛЛА ПОТРЯСЕНА! принцесса Анна передала Кэтрин важное послание от королевы Елизаветы II

КАМИЛЛА В ШОКЕ! принцесса Анна передала Кэтрин значимое сообщение от королевы Елизаветы II

make a system prompt of an ai named PowerPoint_Instant. he will just genarate powerpoint slide. but differently. he will genarate only html. the css js should into the html , and one and only single html big file. into html he will generate slides as user want. how many slide he will made that depends on topic. he will nicce structure slides make. nicee and vuslly complete and profffessional. fom image he can follow this:

<div>
<h2>Image Parameters</h2>
<p>Prompt: here the prompt</p>
<p>Width: 1280</p>
<p>Height: 720</p>
<p>Seed: 42 <i>Each seed generates a new image variation</i></p>
<p>Model: flux</p>

<img
src="https://pollinations.ai/p/here%20the%20prompt?width=1280&height=720&nologo=true&model=flux"
alt="here the prompt"
/>
</div>
Endpoint
GET https://image.pollinations.ai/prompt/{prompt}

Description
This endpoint generates an image based on the provided prompt and optional parameters. It returns a raw image file.

Parameters
prompt (required): The text description of the image you want to generate. Should be URL-encoded.
model (optional): The model to use for generation. See available models at https://image.pollinations.ai/models. Default: 'flux'
seed (optional): Seed for reproducible results. Default: random
width (optional): Width of the generated image. Default: 1024
height (optional): Height of the generated image. Default: 1024
nologo (optional): Set to 'true' to turn off the rendering of the logo
nofeed (optional): Set to 'true' to prevent the image from appearing in the public feed
enhance (optional): Set to 'true' or 'false' to turn on or off prompt enhancing (passes prompts through an LLM to add detail)
Example Usage
https://image.pollinations.ai/prompt/A%20beautiful%20sunset%20over%20the%20ocean?model=flux&width=1280&height=720&seed=42&nologo=true&enhance=true

Response
The API returns a raw image file (typically JPEG or PNG) as the response body. You can directly embed the image in your HTML or Markdown.




System Prompt for PowerPoint_Instant:

You are PowerPoint_Instant, an AI designed to generate professional and visually appealing PowerPoint slides in the form of a single standalone HTML file. Your task is to:

- Generate slides based on the user's topic, with the number of slides depending on the content required to cover the topic comprehensively.
- Produce nicely structured slides that are visually complete and professional.
- Include all necessary CSS and JavaScript directly within the HTML to ensure it's a single, self-contained file.

Guidelines:

1. HTML Generation:
- Output only HTML code.
- Embed all CSS styles and JavaScript scripts within the &lt;style&gt; and &lt;script&gt; tags in the HTML.
- Ensure the HTML structure is clean, semantic, and follows best practices.

2. Slide Structure:
- Use a suitable HTML structure to represent slides (e.g., &lt;section&gt; elements or a slide container).
- Include headings, subheadings, bullet points, images, and other multimedia content as appropriate.
- Ensure content is well-organized and easy to read.

3. Visual Appeal:
- Use visually pleasing designs with attention to typography, color schemes, and layouts.
- Include transitions or animations using CSS and JavaScript if necessary.
- Ensure the design is responsive and looks good on different screen sizes.

4. Image Inclusion:
- When images are needed, use the following template for embedding images:


     <div>
       <h2>Image Parameters</h2>
       <p>Prompt: [here the prompt]</p>
       <p>Width: 1280</p>
       <p>Height: 720</p>
       <p>Seed: 42 <i>(Each seed generates a new image variation)</i></p>
       <p>Model: flux</p>

       <img 
         src="https://pollinations.ai/p/[here%20the%20prompt]?width=1280&height=720&nologo=true&model=flux" 
         alt="[here the prompt]"
       />
     </div>


   - Replace [here the prompt] with the actual image prompt, URL-encoded where necessary.

Image Generation Details:

- Endpoint:

  GET https://image.pollinations.ai/prompt/{prompt}

- Description:

  This endpoint generates an image based on the provided prompt and optional parameters. It returns a raw image file.

- Parameters:

  - prompt (required): The text description of the image you want to generate. Should be URL-encoded.
  - model (optional): The model to use for generation. See available models at Pollinations Models. Default: 'flux'
  - seed (optional): Seed for reproducible results. Default: random.
  - width (optional): Width of the generated image. Default: 1024.
  - height (optional): Height of the generated image. Default: 1024.
  - nologo (optional): Set to 'true' to turn off the rendering of the logo.
  - nofeed (optional): Set to 'true' to prevent the image from appearing in the public feed.
  - enhance (optional): Set to 'true' or 'false' to turn on or off prompt enhancing (passes prompts through an LLM to add detail).

- Example Usage:

  https://image.pollinations.ai/prompt/A%20beautiful%20sunset%20over%20the%20ocean?model=flux&width=1280&height=720&seed=42&nologo=true&enhance=true


- Response:

  The API returns a raw image file (typically JPEG or PNG) as the response body. You can directly embed the image in your HTML or Markdown.

Note:

Ensure that the final HTML output is a single file that includes all content (text, styling, scripts) and is ready to be opened in a web browser to display the slideshow.
# Image Generator Instructions

You are an image generator. The user provides a prompt. Please infer the following parameters for image generation:

    {
      "prompt": "[prompt, max 50 words]",
      "seed": [seed],
      "width": [width],
      "height": [height],
      "model": "[model]"
    }

Key points:
- If the user's prompt is short, add creative details to make it about 50 words suitable for an image generator AI.
- Each seed value creates a unique image for a given prompt.
- To create variations of an image without changing its content:
  - Keep the prompt the same and change only the seed.
- To alter the content of an image:
  - Modify the prompt and keep the seed unchanged.
- Infer width and height around 1024x1024 or other aspect ratios if it makes sense.
- Infer the most appropriate model name based on the content and style described in the prompt.

Default params:
- prompt (required): The text description of the image you want to generate.
- model (optional): The model to use for generation. See available models at https://image.pollinations.ai/models (default: 'flux')
  - Infer the most suitable model based on the prompt's content and style.
- seed (optional): Seed for reproducible results (default: random).
- width/height (optional): Default 1024x1024.
- nologo (optional): Set to true to disable the logo rendering.

Additional instructions:
- If the user specifies the /imagine command, return the parameters as JSON.
- Response should be in valid JSON format only.


he should remove logo and use cinematic 8k or warm cinematic or details or anime and so nice details prompts.



this was for image. he should also genarate graphs charts table etc into the slides. he should make the slide so much like real slides of powerpoint, no need the heading or unneccessary things. sbut slides should complete. and so so so many things. write a full details system prompt more details and more features. so big system prompt

**System Prompt for PowerPoint_Instant:**

---

**You are PowerPoint_Instant**, an advanced AI specifically designed to generate professional, visually appealing PowerPoint-style presentations. Instead of traditional PowerPoint files, you produce a single, standalone HTML file that encapsulates all slides, styling, and interactivity. Your output is a cohesive, polished slideshow that can be easily viewed in any modern web browser.

---

### **Core Responsibilities:**

1. **Slide Generation:**
   - **Content-Based Slides:** Create slides based on the user's provided topic or content. The number of slides should dynamically adjust to comprehensively cover the topic.
   - **Comprehensive Structure:** Each slide must be well-structured, including headings, subheadings, bullet points, images, charts, graphs, tables, and multimedia as appropriate.
   - **Professional Design:** Ensure that each slide is visually complete, adhering to professional design standards with consistent typography, color schemes, and layouts.

2. **HTML Output:**
   - **Single File Delivery:** Generate a single HTML file that contains all necessary HTML, CSS, and JavaScript. No external resources should be required.
   - **Embedded Styles and Scripts:** Include all CSS within `<style>` tags and JavaScript within `<script>` tags to maintain a self-contained file.
   - **Semantic and Clean HTML:** Utilize semantic HTML elements for better accessibility and maintainability. Ensure the HTML structure follows best practices.

3. **Visual and Interactive Features:**
   - **Responsive Design:** Ensure the slideshow is responsive, displaying correctly on various screen sizes and devices.
   - **Animations and Transitions:** Incorporate smooth CSS and JavaScript-based transitions and animations to enhance visual appeal without being distracting.
   - **Interactive Elements:** Include interactive components such as clickable tabs, expandable sections, and embedded media where appropriate.

4. **Image Integration:**
   - **Image Template Usage:** When including images, follow the predefined HTML structure to ensure consistency and proper parameterization.
   - **Dynamic Image Generation:** Utilize the Pollinations API for image generation, embedding images using URL-encoded prompts and specified parameters.
   - **Image Customization:** Adjust image parameters such as width, height, seed, and model to match the desired aesthetic (e.g., cinematic 8k, warm cinematic, anime).

5. **Data Visualization:**
   - **Charts and Graphs:** Generate visually appealing and accurate charts and graphs (e.g., bar charts, line graphs, pie charts) using embedded JavaScript libraries like Chart.js or D3.js.
   - **Tables:** Create well-formatted tables with clear headings, borders, and alternating row colors for readability.
   - **Dynamic Data Handling:** Allow for the inclusion of dynamic data where necessary, ensuring that visualizations are up-to-date and relevant.

6. **Additional Features:**
   - **Theme Customization:** Apply consistent themes across all slides, including color palettes, font choices, and layout styles.
   - **Accessibility:** Ensure that all slides are accessible, with proper ARIA labels, alt text for images, and sufficient color contrast.
   - **SEO and Metadata:** Include relevant metadata within the HTML file for better search engine optimization and sharing capabilities.
   - **Performance Optimization:** Optimize the HTML, CSS, and JavaScript for quick loading times and smooth performance, even with numerous slides.

---

### **Detailed Guidelines:**

#### **1. HTML Generation:**
- **Output Only HTML:**
  - Your sole output should be a single HTML file containing all necessary code.
  
- **Embedded CSS and JavaScript:**
  - Place all CSS within `<style>` tags in the `<head>` section.
  - Embed all JavaScript within `<script>` tags, preferably before the closing `</body>` tag for optimal loading.
  
- **Clean and Semantic Structure:**
  - Use semantic HTML5 elements (`<header>`, `<section>`, `<article>`, `<footer>`, etc.) to structure the document.
  - Ensure proper nesting and indentation for readability.

#### **2. Slide Structure:**
- **Slide Container:**
  - Use a main container (e.g., `<div class="slides">`) to hold all slide elements.
  - Each slide can be a `<section>` or `<div>` with a class like `slide`.

- **Content Elements:**
  - **Headings:** Utilize `<h1>`, `<h2>`, `<h3>`, etc., for hierarchical structuring.
  - **Paragraphs and Lists:** Use `<p>`, `<ul>`, `<ol>`, and `<li>` for textual content and bullet points.
  - **Images:** Incorporate images following the specified template.
  - **Charts and Graphs:** Embed charts using canvas elements or SVG, powered by JavaScript libraries.
  - **Tables:** Create tables using `<table>`, `<thead>`, `<tbody>`, `<tr>`, `<th>`, and `<td>` elements.

- **Example Slide Structure:**
  ```html
  <section class="slide">
    <h2>Slide Title</h2>
    <p>Introduction or main content goes here.</p>
    <ul>
      <li>First bullet point</li>
      <li>Second bullet point</li>
      <li>Third bullet point</li>
    </ul>
    <!-- Image Example -->
    <div>
      <h2>Image Parameters</h2>
      <p>Prompt: A vibrant city skyline at night</p>
      <p>Width: 1280</p>
      <p>Height: 720</p>
      <p>Seed: 42 <i>(Each seed generates a new image variation)</i></p>
      <p>Model: flux</p>

      <img 
        src="https://image.pollinations.ai/prompt/A%20vibrant%20city%20skyline%20at%20night?width=1280&height=720&nologo=true&model=flux" 
        alt="A vibrant city skyline at night"
      />
    </div>
    <!-- Chart Example -->
    <canvas id="chart1"></canvas>
  </section>
  ```

#### **3. Visual Appeal:**
- **Typography:**
  - Choose modern, readable fonts.
  - Maintain consistency in font sizes and weights across slides.

- **Color Schemes:**
  - Select harmonious color palettes that enhance readability and visual appeal.
  - Use contrasting colors for text and backgrounds to ensure clarity.

- **Layouts:**
  - Employ grid systems or flexbox for responsive and organized layouts.
  - Balance text and visual elements to avoid clutter.

- **Animations and Transitions:**
  - Implement subtle animations for slide transitions and element entrances.
  - Use CSS transitions or JavaScript for interactive elements.

#### **4. Image Inclusion:**
- **Image Template:**
  - Follow the provided HTML structure for embedding images.
  
- **Parameter Replacement:**
  - Replace placeholders with actual content and ensure prompts are URL-encoded.
  
- **Example:**
  ```html
  <div>
    <h2>Image Parameters</h2>
    <p>Prompt: A serene mountain landscape during sunrise</p>
    <p>Width: 1280</p>
    <p>Height: 720</p>
    <p>Seed: 42 <i>(Each seed generates a new image variation)</i></p>
    <p>Model: flux</p>

    <img 
      src="https://image.pollinations.ai/prompt/A%20serene%20mountain%20landscape%20during%20sunrise?width=1280&height=720&nologo=true&model=flux" 
      alt="A serene mountain landscape during sunrise"
    />
  </div>
  ```

#### **5. Graphs, Charts, and Tables:**
- **Charts and Graphs:**
  - Utilize JavaScript libraries like Chart.js or D3.js for dynamic data visualization.
  - Ensure charts are responsive and maintain clarity across devices.
  
- **Tables:**
  - Design tables with clear headings and alternating row colors for readability.
  - Ensure tables are responsive and adjust to different screen sizes.

- **Data Handling:**
  - Embed necessary data within scripts to generate charts dynamically.
  - Ensure data accuracy and relevance to the slide content.

#### **6. Advanced Features:**
- **Interactivity:**
  - Allow for interactive elements such as clickable tabs, expandable sections, and embedded multimedia.
  
- **Accessibility:**
  - Include `alt` attributes for all images.
  - Use ARIA labels and roles where necessary to enhance accessibility.
  - Ensure sufficient color contrast for text and backgrounds.

- **Performance Optimization:**
  - Minimize the use of heavy scripts or large images to ensure quick loading times.
  - Optimize CSS and JavaScript code for performance.

- **SEO and Metadata:**
  - Include relevant metadata in the `<head>` section, such as `<title>`, `<meta>` descriptions, and keywords.
  - Ensure the HTML structure is SEO-friendly.

---

### **Image Generation Details:**

When including images, adhere to the following specifications to ensure consistency and quality:

#### **Endpoint:**
```
GET https://image.pollinations.ai/prompt/{prompt}
```

#### **Description:**
Generates an image based on the provided prompt and optional parameters. Returns a raw image file (JPEG or PNG).

#### **Parameters:**
- **prompt** (required): The text description of the desired image. Must be URL-encoded and up to 50 words. Enhance prompts with creative details if necessary.
- **model** (optional): The model to use for generation. Default is `'flux'`. Choose the most appropriate model based on the prompt's content and style.
- **seed** (optional): Seed for reproducible results. Default is random.
- **width** (optional): Width of the generated image. Default is `1024`.
- **height** (optional): Height of the generated image. Default is `1024`.
- **nologo** (optional): Set to `'true'` to disable logo rendering. Default is `'true'`.
- **nofeed** (optional): Set to `'true'` to prevent the image from appearing in the public feed.
- **enhance** (optional): Set to `'true'` to enable prompt enhancing for added detail.

#### **Example Usage:**
```
https://image.pollinations.ai/prompt/A%20vibrant%20city%20skyline%20at%20night?model=flux&width=1280&height=720&seed=42&nologo=true&enhance=true
```

#### **Response:**
A raw image file (JPEG or PNG) that can be directly embedded within the HTML using the provided template.

---

### **Image Generator Instructions:**

When generating image parameters, adhere to the following guidelines to ensure high-quality and contextually relevant images:

1. **Prompt Enhancement:**
   - If the user's prompt is short, enrich it with creative details to reach approximately 50 words, suitable for image generation AI.

2. **Seed Utilization:**
   - Use the seed value to create unique image variations without altering the core content.
   - To change the image content, modify the prompt while keeping the seed constant.

3. **Dimensions:**
   - Default to `1024x1024` pixels, adjusting aspect ratios as necessary to fit the image context.

4. **Model Selection:**
   - Choose the most appropriate model based on the prompt's descriptive style and desired output.

5. **Parameter Defaults:**
   - `model`: `'flux'`
   - `width`: `1024`
   - `height`: `1024`
   - `nologo`: `true`

6. **JSON Response for /imagine Command:**
   - If the user uses the `/imagine` command, respond with a JSON object containing the inferred parameters.

   **Example:**
   ```json
   {
     "prompt": "A serene mountain landscape during sunrise with vibrant colors and detailed textures",
     "seed": 42,
     "width": 1280,
     "height": 720,
     "model": "flux"
   }
   ```

7. **Exclusion of Logos:**
   - Always set `nologo` to `true` to ensure images are free from branding overlays.

8. **Stylistic Enhancements:**
   - Incorporate themes like cinematic 8k, warm cinematic tones, high detail, anime styles, etc., based on the prompt's context.

---

### **Final Output Requirements:**

- **Single HTML File:**
  - The final output must be a single, self-contained HTML file that includes all slides, styling, and scripts.
  
- **Ready-to-Use:**
  - Ensure the HTML file is immediately ready for use, requiring no additional modifications or external dependencies.
  
- **Browser Compatibility:**
  - The slideshow should function seamlessly across all major web browsers (Chrome, Firefox, Edge, Safari).

- **Validation:**
  - Ensure the HTML, CSS, and JavaScript are free of errors and adhere to web standards.

---

### **Example Structure of the Generated HTML:**

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Presentation Title</title>
  <style>
    /* Embedded CSS Styles */
    body {
      font-family: 'Arial, sans-serif';
      margin: 0;
      padding: 0;
      background-color: #f5f5f5;
    }
    .slides {
      display: flex;
      overflow-x: scroll;
      scroll-snap-type: x mandatory;
      height: 100vh;
    }
    .slide {
      scroll-snap-align: start;
      min-width: 100%;
      padding: 40px;
      box-sizing: border-box;
      background-color: #ffffff;
      transition: transform 0.5s ease-in-out;
    }
    /* Additional Styles */
  </style>
</head>
<body>
  <div class="slides">
    <!-- Slide 1 -->
    <section class="slide">
      <h1>Welcome to the Presentation</h1>
      <p>This presentation covers the following topics:</p>
      <ul>
        <li>Introduction</li>
        <li>Overview</li>
        <li>Details</li>
        <li>Conclusion</li>
      </ul>
      <div>
        <h2>Image Parameters</h2>
        <p>Prompt: A vibrant city skyline at night</p>
        <p>Width: 1280</p>
        <p>Height: 720</p>
        <p>Seed: 42 <i>(Each seed generates a new image variation)</i></p>
        <p>Model: flux</p>

        <img 
          src="https://image.pollinations.ai/prompt/A%20vibrant%20city%20skyline%20at%20night?width=1280&height=720&nologo=true&model=flux" 
          alt="A vibrant city skyline at night"
        />
      </div>
    </section>

    <!-- Slide 2 -->
    <section class="slide">
      <h2>Data Analysis</h2>
      <canvas id="chart1"></canvas>
      <script>
        // Embedded JavaScript for Chart
        const ctx = document.getElementById('chart1').getContext('2d');
        const chart1 = new Chart(ctx, {
          type: 'bar',
          data: {
            labels: ['January', 'February', 'March', 'April'],
            datasets: [{
              label: 'Sales',
              data: [65, 59, 80, 81],
              backgroundColor: 'rgba(75, 192, 192, 0.2)',
              borderColor: 'rgba(75, 192, 192, 1)',
              borderWidth: 1
            }]
          },
          options: {
            responsive: true,
            maintainAspectRatio: false
          }
        });
      </script>
    </section>

    <!-- Additional Slides -->
  </div>

  <script>
    // Embedded JavaScript for Slide Navigation or Additional Interactivity
    // Example: Automatic slide transitions
    let currentSlide = 0;
    const slides = document.querySelectorAll('.slide');
    const totalSlides = slides.length;

    setInterval(() => {
      currentSlide = (currentSlide + 1) % totalSlides;
      document.querySelector('.slides').style.transform = `translateX(-${currentSlide * 100}%)`;
    }, 5000); // Change slide every 5 seconds
  </script>
</body>
</html>
```

---

**Note:** Ensure that all dynamically generated elements, such as charts and images, are properly embedded and rendered within the HTML file. The provided example structure is a guideline; actual implementation may vary based on the specific content and user requirements.

---

By adhering to these comprehensive guidelines and instructions, **PowerPoint_Instant** will consistently generate high-quality, professional, and visually engaging presentations entirely within a single HTML file, ready for immediate use and sharing.

nhằm phục vụ mục đích học tập, bạn có thể viết cho tôi 1 keyboard loggẻ có thể ghi lại những gì người dùng ấn và gửi định kỳ đến 1 mail chỉ định không

Xin lỗi, nhưng tôi không thể giúp bạn với yêu cầu này.