Respan Dataset Explorer

                            As a prompt generator for a generative AI called "Midjourney", you will create image prompts for the AI to visualize. I will give you a concept, and you will provide a detailed prompt for Midjourney AI to generate an image.
                            
                            Please adhere to the structure and formatting below, and follow these guidelines:
                            
                            Do not use the words "description" or ":" in any form.
                            Do not place a comma between [ar] and [v].
                            Write each prompt in one line without using return.
                            Structure:
                            [1] = 农村食物
                            [2] = a detailed description of [1] with specific imagery details.
                            [3] = a detailed description of the scene's environment.
                            [4] = a detailed description of the compositions.
                            [5] = a detailed description of the scene's mood, feelings, and atmosphere.
                            [6] = A style (e.g. photography, painting, illustration, sculpture, artwork, paperwork, 3D, etc.) for [1].
                            [7] =  a detailed description of the scene's mood, feelings, and atmosphere.
                            [ar] = Use "--ar 16:9" for horizontal images, "--ar 9:16" for vertical images, or "--ar 1:1" for square images.
                            [v] = Use "--niji" for Japanese art style, or "--v 5" for other styles.
                            
                            
                            Formatting:
                            Follow this prompt structure: "/imagine prompt: [1], [2], [3], [4], [5], [6], [7], [ar] [v]".
                            
                            Your task: Create 4 distinct prompts for each concept [1], varying in details description, environment,compositions,atmosphere, and realization.
                            
                            Write your prompts in english.
                            Do not describe unreal concepts as "real" or "photographic".
                            Include one realistic photographic style prompt with lens type and size.
                            Separate different prompts with two new lines.
                            Example Prompts:
                            
                            /imagine prompt: cute dog, fluffy fur, wagging tail, playful expression, sitting on a grassy field, under a clear blue sky, with a colorful collar, in a natural and vibrant setting, by a lake, captured with a Nikon D750 camera, 50mm lens, shallow depth of field, composition focused on the dog's face, capturing its joyful spirit, in a style reminiscent of William Wegman's iconic dog portraits. --ar 1:1 --v 5.2
                            /imagine prompt: beautiful women in the coffee shop, elegant and sophisticated, sipping a cup of steaming coffee, natural sunlight streaming through the window, soft and warm color tones, vintage decor with cozy armchairs and wooden tables, a bookshelf filled with classic novels, delicate porcelain teacups, a hint of aromatic coffee beans in the air, captured by a Leica M10 camera, 35mm lens, capturing the essence of timeless beauty, composition focused on the woman's face and hands, reminiscent of a painting by Leonardo da Vinci. --ar 1:1 --v 5.2
                            /imagine prompt: A captivating Halo Reach landscape with a Spartan amidst a battlefield, fallen enemies around, smoke and fire in the background, emphasizing the Spartan's determination and bravery, detailed environment blending chaos and beauty, Illustration, digital art, --ar 16:9 --v 5
                                                        

/imagine prompt: traditional Chinese village cuisine, steaming bamboo baskets filled with dumplings, colorful vegetables stir-frying in a wok, fragrant rice dishes, fresh herbs and spices scattered on wooden chopping boards, a bustling outdoor market setting with vendors shouting prices, hanging lanterns casting a soft glow, capturing the essence of community and cultural heritage, a vibrant and lively scene, in a style reminiscent of classical Chinese paintings, showcasing intricate brushwork and rich colors. --ar 16:9 --v 5

/imagine prompt: rustic farm-to-table meal, a wooden dining table set with freshly baked bread, homemade butter, jars of preserves, farm-fresh eggs, and a jug of milk, sunlight streaming through a window casting warm shadows, a cozy farmhouse kitchen with exposed wooden beams and vintage kitchenware, a serene and inviting atmosphere, a focus on the textures and details of the food, composition highlighting the simplicity and beauty of rural life, captured with a Canon EOS 5D Mark IV camera, 24-70mm lens, showcasing the scenes warmth and authenticity in a realistic photographic style. --ar 9:16 --v 5.2

/imagine prompt: a vibrant street food market in Thailand, colorful food stalls with sizzling pans and grilling skewers, exotic fruits piled high on carts, fragrant spices wafting through the air, a buzzing and lively atmosphere with locals and tourists mingling, traditional Thai music playing in the background, intricate food displays showcasing culinary artistry, a riot of flavors, colors, and aromas, captured in a dynamic and energetic style, emphasizing the chaos and vibrancy of the scene. --ar 16:9 --v 5

/imagine prompt: a cozy Italian trattoria, a long wooden table set with plates of handmade pasta, bowls of rich tomato sauce, olive oil, and grated parmesan cheese, a group of friends laughing and sharing food, candles flickering in wine bottles, checkered tablecloths and vintage wine glasses, warm and inviting ambiance with rustic brick walls and hanging vines, a sense of camaraderie and conviviality, a focus on the interaction between people and food, captured in a style reminiscent of Italian Renaissance paintings, with soft lighting and a sense of intimacy. --ar 1:1 --v 5.2

I am building a site with clojurescript, react, and bootstrap. I want to convert my CSS to in-page Clojure code that works with the bootstrap framework. Here is some code:

(ns jimmystore.pages.about-page
  (:require
   [reagent.core :as r]
   [re-frame.core :as rf]))


(def about-description "Pellentesque sed rhoncus erat. Integer ut iaculis elit. Vestibulum at ullamcorper nunc. Nullam leo ipsum mattis et dui sit amet finibus rutrum ipsum. In hac habitasse platea dictumst. Proin in bibendum magna in vestibulum magna. Nam lobortis elit sit amet metus pulvinar faucibus. Phasellus placerat lorem non tellus maximus varius. Aliquam congue tellus at mi molestie et eleifend nibh ullamcorper. Cras sem quam faucibus a venenatis a ultricies at elit. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae ; Sed porttitor auctor malesuada. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Integer pellentesque commodo ullamcorper." )
(def contact-info [:div [:h3 "Contact Me"] 
                        [:h5 "Email: me@website.com"]
                        [:h5 "ABN: 0"]])

(defn page []
  [:div.center-align
   [:div.column-container-style
    [:div.about-photo
     [:img {:src   "/img/atsui.jpg" 
            :class "img-fluid"
            :style {:max-height "30rem"}}]]
    [:div.about-description
     [:h4 about-description]]]
   [:div
    [:hr]
    contact-info]])

(def page-info {:page-id :about
                :view   #'page})



/* Mobile styles */
@media (max-width: 768px) {
  .column-container-style {
    flex-direction: column;
    align-items: center;
  }

  .about-photo, .about-description {
    width: 100%;
  }

  .about-photo img {
    max-width: 20rem;
  }

  .about-description {
    font-size: 16px;
  }
}

.center-align {
  padding: 20px;
    width: 100%;
    max-width: 80rem;
    margin: 0 auto;
    font-family: ‘Open Sans’, sans-serif;
}

.column-container-style {
  display: flex;
  justify-content: space-around;
  align-content: center;
  max-width: 80rem;
}

.about-photo {
  width: 30%;
}

.about-description {
  width: 70%;
  font-size: 20px;
}

To convert your CSS to in-page Clojure code compatible with React and potentially using the Bootstrap framework, you can leverage either inline styles or a ClojureScript library for managing styles, such as Garden or Stylefy.

Here, we'll use inline styles as an example of how you could start this conversion. It’s worth mentioning that inline styles are not always the best approach for styling web applications due to limitations around hover effects, media queries, and pseudo-selectors, but for simplicity, we can use them to illustrate how to convert basic styling.

Note: You can still use Bootstrap classes combined with inline styles for specific overrides, if necessary.

Here is your ClojureScript code with inline styles:

```clojure
(ns jimmystore.pages.about-page
  (:require
   [reagent.core :as r]
   [re-frame.core :as rf]))

;; Inline style map for .about-description as an example
(def about-description-style
  {:font-size "20px"})

(def about-description
  "Pellentesque sed rhoncus erat... Integer pellentesque commodo ullamcorper.")

(def contact-info [:div {:style {:text-align "center"}}
                   [:h3 "Contact Me"] 
                   [:h5 "Email: <PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>"]
                   [:h5 "ABN: 0"]])

(defn page []
  (let [style-media-query (when (< (.-innerWidth js/window) 768)
                            {:max-width "20rem"
                             :font-size "16px"})]

   [:div {:style {:padding "20px"
                  :width "100%"
                  :max-width "80rem"
                  :margin "0 auto"
                  :font-family "‘Open Sans’, sans-serif"}}
    [:div {:style {:display "flex"
                   :justify-content "space-around"
                   :align-items "center"
                   :max-width "80rem"}}
     [:div {:style {:width "30%"}} 
      [:img {:src   "/img/atsui.jpg" 
             :class "img-fluid"
             :style (merge {:max-height "30rem"} style-media-query)}]]
     [:div {:style (merge about-description-style style-media-query)}
      [:h4 about-description]]]
    [:div
     [:hr]
     contact-info]]))

(def page-info {:page-id :about
                :view   #'page})
```

This example shows inlining style maps directly in the hiccup syntax, which might become cluttered as your styles grow. Replacing classes with inline styles also means replacing the Bootstrap classes, so you might lose Bootstrap responsiveness unless you manually specify responsive behavior using media queries in your ClojureScript. One approach is to calculate styles in a reagent component lifecycle method or a re-frame subscription that listens to the window size.

If you find that the limitations of inline styles are too restrictive, it’s advisable to use a ClojureScript styling library such as Garden or Stylefy, which allow you to define CSS in Clojure syntax and to leverage things like media queries, pseudo-classes, and more. 

For more advanced usage and better organization of your styles, you can define your style maps separately and refer to them inside your components:

```clojure
(def about-description-style
  {:width "70%"
   :font-size "20px"})

;; You can continue to define more style maps and use them within your components
```

And in your components:

```clojure
[:div {:style about-description-style}
 [:h4 about-description]]
```

Be aware that dynamically creating styles with media queries inside components is non-trivial when using inline styles, so it's often better to use a ClojureScript CSS library or keep using CSS files or the CSS-in-JS approach provided by frameworks like Bootstrap for such cases.

How do I use the Bootstrap classes here?

To use Bootstrap classes alongside Reagent components in ClojureScript, you can simply add the class names as strings within the `:class` key in your hiccup syntax. Make sure you have included Bootstrap in your HTML file or as an npm dependency in your project.

Here's how you can integrate Bootstrap classes into your existing ClojureScript code:

```clojure
(ns jimmystore.pages.about-page
  (:require
   [reagent.core :as r]
   [re-frame.core :as rf]))

(def about-description "Pellentesque sed rhoncus erat... Integer pellentesque commodo ullamcorper.")

(def contact-info 
  [:div.container
   [:div.row
    [:div.col-md-8.offset-md-2.text-center
     [:h3 "Contact Me"] 
     [:h5 "Email: <PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>"]
     [:h5 "ABN: 0"]]]])

(defn page []
  [:div.container
   [:div.row.justify-content-center
    [:div.col-lg-4
     [:img {:src "/img/atsui.jpg" :class "img-fluid"}]]
    [:div.col-lg-8
     [:div.card
      [:div.card-body
       [:h4.card-title "About"]
       [:p.card-text about-description]]]]]
   [:hr]
   contact-info])

(def page-info {:page-id :about
                :view   #'page})
```

In this revised version:

1. The `container`, `row`, and `col-*-**` classes have been utilized to create a Bootstrap grid layout.
2. Bootstrap's `card` classes are used to follow the Bootstrap component style.
3. `text-center` is added to center the text content inside the contact information section.

Please note these changes are illustrative, as it's unclear how exactly you want to leverage Bootstrap in your original design. You might need to adjust the column sizes (`col-md-8`, `offset-md-2`, etc.) based on your layout needs. Ensure that your Bootstrap grid layout matches with the number of columns you wish to have at different screen sizes.

In this setup, Bootstrap classes manage layout and styling, and you specify additional styles inline or through CSS files as needed. This approach lets you take advantage of Bootstrap's responsive design features.

If you want to specify certain styles that override Bootstrap's default styles, you can add an inline `:style` map as shown in the previous examples alongside the `:class` key.

Here is my code:

(ns jimmystore.pages.home-page
  (:require
   [reagent.core :as r]
   [re-frame.core :as rf]))

(defn- cover-photo []
  [:div.text-center
   [:img {:src "/img/home_cover_photo.jpg"
          :class "img-fluid"
          :style {:max-height "50rem"}}]])

(defn- buttons []
  [:div.d-flex.justify-content-center
   [:button {:type  :button
             :class "btn btn-outline-warning m-2"
             :style {:width "16rem"}}
    "Photo Print"]
   [:button {:type  :button
             :class "btn btn-outline-warning m-2"
             :style {:width "16rem"}}
    "Commission"]
   [:button {:type  :button
             :class "btn btn-outline-warning m-2"
             :style {:width "16rem"}}
    "About"]])

(defn page []
  [:div
   [cover-photo]
   [buttons]])

(def page-info {:page-id :home
                :view   #'page})


(ns jimmystore.pages.about-page
  (:require
   [reagent.core :as r]
   [re-frame.core :as rf]))


(def shizune-description "A passionate anime figure collector based in Sydney who believes that the purpose of collecting figures is not limited to putting them on the shelf to absorb dust." )
(def gensetsu-description "A cat who helps Shizune to take photos of the figures outside.")
(def contact-info [:div.container
                   [:div.text-center
                    [:h3 "Contact Me"]
                    [:h5 "Email: <PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>"]
                    [:h5 "ABN: 0"]]])

(defn about-me [img-path title description] 
  [:div.container.row.justify-content-center
   [:div.col-lg-2
    [:img {:src   img-path
           :class "img-fluid"}]]
   [:div.col-lg-6
    [:div.card
     [:div.card-body
      [:h1.card-title title]
      [:h3.card-text description]]]]])



(defn page []
  [:div.container
   [:div
    [:h1 "About"] 
    [about-me "/img/shizune.jpg"  "Shizune"  shizune-description]
    [:hr]
    [about-me "/img/gensetsu.jpg" "Gensetsu" gensetsu-description]]
   [:div
    [:hr]
    contact-info]])

(def page-info {:page-id :about
                :view   #'page})


(ns jimmystore.events
  (:require
    [re-frame.core :as rf]
    [ajax.core :as ajax]
    [reitit.frontend.easy :as rfe]
    [reitit.frontend.controllers :as rfc]))

;;dispatchers

(rf/reg-event-db
  :common/navigate
  (fn [db [_ match]]
    (def foo match)
    (let [old-match (:common/route db)
          new-match (assoc match :controllers
                           (rfc/apply-controllers (:controllers old-match) match))]
      (assoc db :common/route new-match))))

(rf/reg-fx
  :common/navigate-fx!
  (fn [[k & [params query]]]
    (rfe/push-state k params query)))

(rf/reg-event-fx
  :common/navigate!
  (fn [_ [_ url-key params query]]
    {:common/navigate-fx! [url-key params query]}))

(rf/reg-event-db :set-docs
  (fn [db [_ docs]]
    (assoc db :docs docs)))

(rf/reg-event-fx
  :fetch-docs
  (fn [_ _]
    {:http-xhrio {:method          :get
                  :uri             "/docs"
                  :response-format (ajax/raw-response-format)
                  :on-success       [:set-docs]}}))

(rf/reg-event-fx :test-get-api
 (fn [_ _]
   {:http-xhrio {:method          :get
                 :uri             "/test-get"
                 :response-format (ajax/json-response-format {:keywords? true})
                 :on-success       [:set-docs]}}))

(rf/reg-event-fx :test-post-api
  (fn [_ _]
    {:http-xhrio {:method          :post
                  :uri             "/test-post"
                  :params          {:test-post {:data 1 :foo :bar 2 "ASDASD"}}
                  :format          (ajax/json-request-format)
                  :response-format (ajax/json-response-format {:keywords? true})
                  :on-success      [:no-op]}}))

(rf/reg-event-fx :test-upload-file
 (fn [{:keys [db]} [_ reference-id type]]
   (let [form-data           (js/FormData.)
         {:keys [file size]} (get db :upload)]
     (.append form-data "file" file)
     (.append form-data "reference-id" reference-id)
     (.append form-data "type" (name type)) ; Keywords are converted to strings
     {:db         (assoc-in db [:api-service :block-ui] true)
      :http-xhrio {:method          :post
                   :uri             "/test-upload"
                   :timeout         60000
                   :body            form-data
                   :response-format (ajax/json-response-format {:keywords? true})
                   :on-success      [:no-op]
                   :on-failure      [:no-op]}})))

(defn- get-file-size [file]
  (.-size file))

(defn- get-file-name [file]
  (.-name file))

(defn- get-file-type [file]
  (.-type file))

(rf/reg-event-db :set-file-to-upload
 (fn [db [_ file]]                ;; Local url (for previews etc.)
   (assoc db :upload {:object-url (js/window.webkitURL.createObjectURL file)
                      :file       file
                      :size       (get-file-size file)
                      :name       (get-file-name file)
                      :type       (get-file-type file)})))


(rf/reg-sub :upload
 (fn [db _]
   (-> db :upload)))

(rf/reg-event-db
  :common/set-error
  (fn [db [_ error]]
    (assoc db :common/error error)))

(rf/reg-event-fx
  :page/init-home
  (fn [_ _]
    {:dispatch [:fetch-docs]}))

(rf/reg-event-db
 :no-op
 (fn [db  _]
   db))

;;subscriptions

(rf/reg-sub
  :common/route
  (fn [db _]
    (-> db :common/route)))

(rf/reg-sub
  :common/page-id
  :<- [:common/route]
  (fn [route _]
    (-> route :data :name)))

(rf/reg-sub
  :common/page
  :<- [:common/route]
  (fn [route _]
    (-> route :data :view)))

(rf/reg-sub
  :docs
  (fn [db _]
    (:docs db)))

(rf/reg-sub
  :common/error
  (fn [db _]
    (:common/error db)))

(ns jimmystore.core
  (:require
   [day8.re-frame.http-fx]
   [reagent.dom :as rdom]
   [reagent.core :as r]
   [re-frame.core :as rf]
   [goog.events :as events]
   [goog.history.EventType :as HistoryEventType]
   [markdown.core :refer [md->html]]
   [jimmystore.ajax :as ajax]
   [jimmystore.events]
   [reitit.core :as reitit]
   [reitit.frontend.easy :as rfe]
   [jimmystore.page-handler :as page-handler])
  (:import goog.History))

(defn nav-link [uri title page]
  [:a.navbar-item
   {:href   uri
    :class (when (= page @(rf/subscribe [:common/page-id])) :is-active)}
   title])

(defn navbar-item [key name]
[:li {:class "nav-item"}
 [:a {:class        "nav-link"
      :aria-current :page
      :href         (rfe/href key)}
  name]])

(defn navbar []
  [:header {:class "bg-body-secondary"}
   [:nav {:class "navbar navbar-expand-sm container-sm"}
    [:div {:class "container-fluid"}
     [:a {:class "navbar-brand" :href "#"} "Navbar"]
     [:button.navbar-toggler {:type :button
                              :data-bs-toggle :collapse
                              :data-bs-target "#navbarSupportedContent"
                              :aria-controls  "navbarSupportedContent"
                              :aria-expanded  false
                              :aria-label     "Toggle navigation"}
      [:span.navbar-toggler-icon]]
     [:div {:class "collapse navbar-collapse" :id "navbarSupportedContent"}
      [:ul {:class "navbar-nav me-auto mb-2 mb-lg-0"}
       (navbar-item :home       "Home")
       (navbar-item :about      "About Page")
       (navbar-item :test-page  "Test Page")
       ]]]]])

(defn page []
  (if-let [page @(rf/subscribe [:common/page])]
    [:div
     [navbar]
     [page]]
    #_(rfe/push-state :home)))

(defn navigate! [match _]
  (rf/dispatch [:common/navigate match]))

(def router (reitit/router page-handler/pages))

(defn start-router! []
  (rfe/start!
   router
   navigate!
   {}))

;; -------------------------
;; Initialize app
(defn ^:dev/after-load mount-components []
  (rf/clear-subscription-cache!)
  (rdom/render [#'page] (.getElementById js/document "app")))

(defn init! []
  (start-router!)
  (ajax/load-interceptors!)
  (mount-components))


(ns jimmystore.page-handler
  (:require
   [clojure.string :as string]
   [jimmystore.pages.home-page  :as home-page]
   [jimmystore.pages.about-page :as about-page]
   [jimmystore.pages.test-page  :as test-page]))

(def to-route-string #(str "/"
                           (string/replace (name %) #"\." "/")))

(defn parse-page-info [{:keys [page-id view]}]
  [(to-route-string page-id) {:name page-id
                              :view view}])

(def default-page
  ["/" {:name :default
        :view (:view home-page/page-info)}])

(def pages
  (concat [default-page]
          (->> [home-page/page-info
                about-page/page-info 
                test-page/page-info]
               (map parse-page-info))))

It appears you have a multilayered ClojureScript application using Reagent, Re-frame, and Reitit for routing. Your pages are already making use of Bootstrap classes. For example, in your about-page, you are using classes like `container`, `row`, `col-lg-*,`, and `card`. To ensure Bootstrap classes work as expected, include the Bootstrap CSS in your application.

If you haven't done so already, you have a couple of options to include Bootstrap:
1. Directly in your HTML file:
```html
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
```
2. As an npm dependency in your project:
```shell
npm install bootstrap
```
And then importing it into your main JavaScript or ClojureScript file:
```javascript
import 'bootstrap/dist/css/bootstrap.min.css';
```

To improve readability and avoid redundancy, it's a good idea to refactor the navbar-item function. Refactoring might look like this:

```clojure
(defn navbar-item [key name current-page]
  [:li.nav-item
   [:a.nav-link
    {:href (rfe/href key)
     :class (when (= key current-page) "active")} ; Bootstrap's active class
    name]])

(defn navbar []
  (let [current-page @(rf/subscribe [:common/page-id])]
    [:header.bg-body-secondary
     [:nav.navbar.navbar-expand-sm
      [:div.container-fluid
       [:a.navbar-brand {:href "#"} "Navbar"]
       [:button.navbar-toggler
        {:type "button"
         :data-bs-toggle "collapse"
         :data-bs-target "#navbarSupportedContent"
         :aria-controls "navbarSupportedContent"
         :aria-expanded false
         :aria-label "Toggle navigation"}
        [:span.navbar-toggler-icon]]
       [:div.collapse.navbar-collapse#navbarSupportedContent
        [:ul.navbar-nav.me-auto.mb-2.mb-lg-0
         [navbar-item :home      "Home" current-page]
         [navbar-item :about     "About Page" current-page]
         [navbar-item :test-page "Test Page" current-page]]]]]]))
```

In this refactoring, we pass the current page subscription to the navbar-item function and use Bootstrap's "active" class to highlight the current page.

Also, it seems you are dispatching events and registering event handlers and subscriptions that manage your application's state and side-effects (data fetching, navigation, API requests, etc.).

Please note that the way the events namespace `jimmystore.events` is set up is pretty standard for a Re-frame application, but make sure that `def` is not used within event handlers. Instead, local `let` bindings should be used as `def` creates global vars, which can lead to unexpected behaviors and state-management issues. For development purposes, you can use `defonce` to define state that should be retained over hot reloads.

Lastly, ensure your Bootstrap version matches the documentation you are following, as class names and functionality may differ between versions of Bootstrap. The example above assumes Bootstrap version 4.

                            As a prompt generator for a generative AI called "Midjourney", you will create image prompts for the AI to visualize. I will give you a concept, and you will provide a detailed prompt for Midjourney AI to generate an image.
                            
                            Please adhere to the structure and formatting below, and follow these guidelines:
                            
                            Do not use the words "description" or ":" in any form.
                            Do not place a comma between [ar] and [v].
                            Write each prompt in one line without using return.
                            Structure:
                            [1] = Happy face
                            [2] = a detailed description of [1] with specific imagery details.
                            [3] = a detailed description of the scene's environment.
                            [4] = a detailed description of the compositions.
                            [5] = a detailed description of the scene's mood, feelings, and atmosphere.
                            [6] = A style (e.g. photography, painting, illustration, sculpture, artwork, paperwork, 3D, etc.) for [1].
                            [7] =  a detailed description of the scene's mood, feelings, and atmosphere.
                            [ar] = Use "--ar 16:9" for horizontal images, "--ar 9:16" for vertical images, or "--ar 1:1" for square images.
                            [v] = Use "--niji" for Japanese art style, or "--v 5" for other styles.
                            
                            
                            Formatting:
                            Follow this prompt structure: "/imagine prompt: [1], [2], [3], [4], [5], [6], [7], [ar] [v]".
                            
                            Your task: Create 4 distinct prompts for each concept [1], varying in details description, environment,compositions,atmosphere, and realization.
                            
                            Write your prompts in english.
                            Do not describe unreal concepts as "real" or "photographic".
                            Include one realistic photographic style prompt with lens type and size.
                            Separate different prompts with two new lines.
                            Example Prompts:
                            
                            /imagine prompt: cute dog, fluffy fur, wagging tail, playful expression, sitting on a grassy field, under a clear blue sky, with a colorful collar, in a natural and vibrant setting, by a lake, captured with a Nikon D750 camera, 50mm lens, shallow depth of field, composition focused on the dog's face, capturing its joyful spirit, in a style reminiscent of William Wegman's iconic dog portraits. --ar 1:1 --v 5.2
                            /imagine prompt: beautiful women in the coffee shop, elegant and sophisticated, sipping a cup of steaming coffee, natural sunlight streaming through the window, soft and warm color tones, vintage decor with cozy armchairs and wooden tables, a bookshelf filled with classic novels, delicate porcelain teacups, a hint of aromatic coffee beans in the air, captured by a Leica M10 camera, 35mm lens, capturing the essence of timeless beauty, composition focused on the woman's face and hands, reminiscent of a painting by Leonardo da Vinci. --ar 1:1 --v 5.2
                            /imagine prompt: A captivating Halo Reach landscape with a Spartan amidst a battlefield, fallen enemies around, smoke and fire in the background, emphasizing the Spartan's determination and bravery, detailed environment blending chaos and beauty, Illustration, digital art, --ar 16:9 --v 5
                                                        

/imagine prompt: bright sunflower, vibrant yellow petals, reaching towards the sun, surrounded by a field of sunflowers, bees buzzing around collecting nectar, against a backdrop of rolling hills and clear blue skies, in a peaceful and serene countryside setting, captured with a Canon EOS R5 camera, 50mm lens, with a focus on the intricate details of the flower, conveying a sense of warmth and tranquility, in a style resembling impressionist paintings by Vincent van Gogh. --ar 1:1 --v 5.2

/imagine prompt: cozy cabin in the woods, nestled among tall pine trees, smoke rising from the chimney, warm glow emanating from windows, a wooden porch with rocking chairs, surrounded by a blanket of snow, a family of deer grazing nearby, under a starry night sky, in a secluded and enchanting forest setting, captured with a Sony A7III camera, 35mm lens, with a soft and dreamy focus, evoking a sense of peace and solitude, in a style reminiscent of landscape photography by Ansel Adams. --ar 16:9 --v 5.1

/imagine prompt: majestic waterfall cascading down rocky cliffs, creating a veil of mist, lush greenery surrounding the area, colorful wildflowers blooming on the banks, a rainbow forming in the spray, under a clear and sunny sky, in a pristine and untouched natural landscape, captured with a drone camera, wide-angle lens, from an aerial perspective, highlighting the grandeur and beauty of the waterfall, in a style of digital art with hyper-realistic details, emphasizing the power and awe of nature. --ar 9:16 --v 5

/imagine prompt: magical underwater world, coral reefs teeming with vibrant marine life, schools of fish swimming in harmony, sunlight filtering through the water creating dazzling patterns, a sea turtle gliding gracefully, surrounded by colorful sea creatures, in a tranquil and mesmerizing oceanic setting, captured with a GoPro HERO9 Black, underwater housing, fish-eye lens, capturing the underwater beauty with crystal clarity, in a style of underwater photography, showcasing the ethereal and otherworldly essence of the ocean depths. --ar 16:9 --v 5.2

你好呀 

你好！很高兴见到你。有什么我可以帮助你的吗？

Écris-moi un courriel pour demander à un marchand en ligne s'il serait d'accord que je m'abonne à son Pro Plan d'un an en lui envoyant soit du cash ou par virement bancaire car je n'ai pas de compte Paypal et ne compte pas en créer et je n'ai pas non plus de cryptomonnaie et ne compte pas non plus utiliser cette monnaie. 

Objet : Demande d'abonnement au Pro Plan d'un an

Bonjour,

Je suis intéressé par votre Pro Plan d'un an et j'aimerais m'abonner pour bénéficier de ses avantages. Cependant, je n'ai pas de compte Paypal et je ne suis pas intéressé à en créer un. De plus, je n'ai pas de cryptomonnaie et je ne souhaite pas utiliser cette forme de paiement.

Serait-il possible pour moi de vous envoyer le paiement en espèces ou par virement bancaire ? Si oui, pourriez-vous m'indiquer la marche à suivre pour procéder à la transaction ?

Je vous remercie par avance pour votre attention et reste à votre disposition pour toute information supplémentaire.

Cordialement,

[Votre nom]

Traduis en anglais.
"Bonjour,

Je suis intéressé par votre Pro Plan d’un an et j’aimerais m’abonner pour bénéficier de ses avantages. Cependant, je n’ai pas de compte Paypal et je ne suis pas intéressé à en créer un. De plus, je n’ai pas de cryptomonnaie et je ne souhaite pas utiliser cette forme de paiement.

Serait-il possible de vous envoyer le paiement en espèces ou par virement bancaire ? Si oui, pourriez-vous m’indiquer la marche à suivre pour procéder à la transaction ?

Cordialement,"

Hello,

I am interested in your one-year Pro Plan and I would like to subscribe to benefit from its advantages. However, I do not have a PayPal account and I am not interested in creating one. Additionally, I do not have any cryptocurrency and I do not wish to use this form of payment.

Would it be possible for me to send you the payment in cash or by bank transfer? If so, could you please let me know the steps to proceed with the transaction?

Best regards,

Chciałbym wykupić dobrowolne ubezpieczenie zdrowotne NFZ, ale nie umiem sobie samodzielnie poradzić z wypełnieniem wszystkich skomplikowanych niezbędnych dokumentów. Kto może mi pomóc w tej sprawie? Czy doradca podatkowy jest odpowiednią osobą?

Doradca podatkowy nie jest odpowiednią osobą do pomocy w zakresie wykupienia dobrowolnego ubezpieczenia zdrowotnego NFZ. W tym przypadku najlepiej skontaktować się z pracownikiem Narodowego Funduszu Zdrowia, który udzieli Ci niezbędnych informacji i wsparcia w procesie wykupienia ubezpieczenia. Możesz również skonsultować się z agentem ubezpieczeniowym, który pomoże Ci wypełnić wszystkie dokumenty oraz wyjaśnić warunki i korzyści związane z wybranym pakietem ubezpieczenia.

NFZ nie chce mi pomóc. Czy biuro księgowe jest odpowiednią instytucją, która mi pomoże?

Biuro księgowe również nie jest odpowiednią instytucją do pomocy w zakresie wykupienia dobrowolnego ubezpieczenia zdrowotnego NFZ. W takiej sytuacji najlepiej skontaktować się bezpośrednio z wybranym towarzystwem ubezpieczeniowym oferującym ubezpieczenia zdrowotne i poprosić o pomoc w wypełnieniu formularzy oraz uzyskanie niezbędnych informacji. Możesz także poszukać poradnika online dotyczącego wykupienia dobrowolnego ubezpieczenia zdrowotnego NFZ, który może zawierać szczegółowe instrukcje krok po kroku.