DEV Community: Rushikesh Pundkar

(BOOST)

Rushikesh Pundkar — Sat, 18 Oct 2025 07:59:15 +0000

Ai secured GitHub system integrate

Rushikesh Pundkar ・ Oct 18

Ai secured GitHub system integrate

Rushikesh Pundkar — Sat, 18 Oct 2025 07:57:45 +0000

This repository, AI-Secure-build-for-github, is for an "Ai secured deployment," likely a template for an application utilizing the Gemini API with a focus on security.

Here are a few prompts you could use with the AI application this repository is designed to deploy, depending on its specific function:

Prompts for AI Secure Deployment

Security Analysis Prompt: > "Analyze the provided Python dependency list for potential security vulnerabilities and suggest equivalent, well-maintained packages or specific version updates to mitigate high-severity risks."
Infrastructure Prompt: > "Draft a secure Terraform configuration for deploying a Gemini API service to Google Cloud Run, ensuring the service account uses the principle of least privilege and all secrets are managed via Secret Manager."
Code Review Prompt: > "Review the services/ai_handler.ts file for any hardcoded API keys or insecure handling of user inputs, and propose changes to comply with OWASP top 10 secure coding practices."

accessible-todo-app

Rushikesh Pundkar — Thu, 16 Oct 2025 15:32:06 +0000

Repo:https://github.com/rushikesh648/accessible-todo-app

Frontend Development Prompt: Accessible To-Do List App

Project Goal: Implement a simple, single-page To-Do List application that is designed from the ground up for accessibility, ensuring a robust and intuitive experience for all users, including those relying on screen readers and keyboard navigation.

Technology Stack:

HTML5: Semantic structure, ARIA attributes.

CSS3: Styling, clear focus indicators, basic responsive design.

JavaScript (Vanilla JS): Core logic, DOM manipulation, accessibility API interaction.

Part 1: Core Application Structure & Styling

HTML Structure (index.html):

Create a well-structured index.html file.

Include a <!DOCTYPE html> declaration and lang="en" on the tag.

Set up a

with appropriate tags and a .

Implement the main layout with a containing the app title (

), a section for the form and task list, and an optional .

Include an empty

Add a hidden aria-live="polite" region (e.g.,

Base CSS Styling (style.css):

Apply a clean, high-contrast default theme for readability.

Define the .sr-only class to visually hide content while keeping it accessible to screen readers.

Ensure all interactive elements (input fields, buttons) have a clear, visible outline style when they receive :focus (e.g., outline: 2px solid #007bff; outline-offset: 2px;). This is crucial for keyboard navigation.

Style the main containers, form elements, and list items for basic presentation.

JavaScript Initialization (script.js):

Ensure your script runs after the DOM is fully loaded (DOMContentLoaded event).

Define an array to hold your to-do items (e.g., let todos = []; where each item is an object { id: number, text: string, completed: boolean }).

Create a function renderTodos() that clears the existing list and dynamically populates the todo-list

Part 2: Essential Features & Accessibility Implementation

For each feature below, ensure full keyboard navigability and clear screen reader feedback.

Add New To-Do Item:

HTML:

Create a

element containing a explicitly linked to an field (e.g., for="new-todo-item").

Include a "Add Item" .

Add a placeholder attribute to the input as a hint (not a label replacement).

Include an element for displaying error messages (e.g.,

JavaScript:

Attach an event listener to the form's submit event.

Prevent default form submission.

Get the value from the input field.

Validation: If the input is empty:

Display an error message to the user.

Update the error-message element's text and make it visible.

Set aria-invalid="true" on the input field.

Crucially, set focus back to the input field (input.focus()).

If valid:

Add a new to-do object to the todos array.

Clear the input field.

Call renderTodos() to update the list.

Use the screen-reader-announcer to announce the addition (e.g., "New task added: [Task Text].").

Return focus to the input field for quick subsequent additions.

Display To-Do Items:

JavaScript (within renderTodos()):

For each to-do item in the todos array, create an

element.

Inside each

, include:

A to display the task text.

A "Complete" button.

A "Delete" button.

Accessibility:

Dynamically add aria-label attributes to the "Complete" and "Delete" buttons, making them descriptive (e.g., Complete, Delete).

If a task is completed, apply a visual strikethrough effect to its text via CSS.

If a task is completed, also add an aria-label to the text (e.g., ).

Mark To-Do as Complete/Incomplete:

JavaScript:

Attach event listeners to the "Complete" buttons (use event delegation if generating many buttons).

Toggle the completed status of the corresponding to-do item in the todos array.

Call renderTodos() to refresh the display.

Use the screen-reader-announcer to announce the status change (e.g., "Task [Task Text] marked as complete.").

Delete To-Do Item:

JavaScript:

Attach event listeners to the "Delete" buttons.

Remove the corresponding to-do item from the todos array.

Call renderTodos() to refresh the display.

Use the screen-reader-announcer to announce the deletion (e.g., "Task [Task Text] deleted.").

Return focus to the input field after deletion for a smooth workflow.

No Tasks Message:

HTML: Include a

No tasks yet. Add one above!

JavaScript: Dynamically show/hide this message based on whether the todos array is empty.

Part 3: Testing & Deliverables

Self-Evaluation:

Keyboard-Only Test: Can you add, complete, and delete tasks using only the keyboard (Tab, Shift+Tab, Enter, Space)? Does focus move logically?

Screen Reader Test: (Simulate or use a real screen reader like NVDA/VoiceOver) Does the screen reader announce form labels, button actions, and dynamic updates (additions, completions, deletions) clearly and correctly? Are error messages announced promptly?

Deliverables:

Functional Frontend App: index.html, style.css, script.js files.

Clear Code Comments: Especially for accessibility-specific choices (ARIA attributes, focus management, announcements).

A README.md file in the project root containing:

A brief overview of your accessible To-Do List App.

Instructions on how to run the application locally.

A summary of the key accessibility features implemented.

Your findings from the self-evaluation/screen reader testing.

Success Criteria:

The application is fully functional and responsive to user input.

All interactive elements are reachable and operable via keyboard.

Screen reader users receive accurate and helpful feedback for all interactions and dynamic content changes.

The UI is clean and maintains good contrast.

The code is well-organized and easy to understand.

This prompt provides a comprehensive guide for building an accessible To-Do List, ensuring the developer considers inclusivity at every step.

ai application

Rushikesh Pundkar — Sat, 11 Oct 2025 09:31:31 +0000

https://github.com/rushikesh648/Ai-dashboard

Food distribution portal

Rushikesh Pundkar — Thu, 09 Oct 2025 11:10:51 +0000

🎃 Hacktoberfest Challenge: Food-Distribution-Portal- 🍽️

Repository: rushikesh648/Food-distribution-portal-
https://github.com/rushikesh648/Food-distribution-portal-
Project Goal: To create a web portal that facilitates the distribution of food, connecting donors/organizations with those in need.

The Challenge: Boost Developer Experience and Project Setup

The current portal needs foundational contributions to make it easier for future developers to join and contribute. Your challenge is to improve the documentation, code quality, or development workflow.

Choose one (or more!) of the following tasks to complete:

1. 📝 Documentation Master (Highest Priority)

The project currently lacks a detailed description. Create a comprehensive README.md file that includes:

A brief, engaging Project Description.
A list of Technologies Used (e.g., JavaScript, React/JSX).
Clear Installation/Setup Instructions (How to clone, install dependencies, and run the project locally).
A Contributing Guide (simple steps on how to submit a PR).

2. ✨ Code Quality Guardian

Help enforce a consistent coding style across the project's JavaScript/JSX files:

Set up Prettier to handle code formatting automatically.
Set up ESLint with a modern configuration (e.g., Airbnb or Standard config) to catch common errors and ensure best practices.
(Bonus) Add a lint script to package.json and fix any existing style issues across the codebase.

3. 🧪 First Feature Test

The repository contains an App_test.js file, suggesting the intent for testing exists.

Set up a Testing Framework (e.g., Jest and React Testing Library).
Write and successfully run a single unit test for one of the existing components (e.g., App.js or Internal-dash-compo.jsx). This test should confirm that a component renders without crashing.

How to Participate:

Fork the repository: https://github.com/rushikesh648/Food-distribution-portal-
Create a new branch for your feature/fix.
Commit your changes and make sure they meet the challenge criteria.
Submit a Pull Request (PR) and mention the task you completed (e.g., "Feat: Add comprehensive README.md" or "Chore: Setup ESLint and Prettier").

Happy Hacking!

App

Rushikesh Pundkar — Thu, 09 Oct 2025 02:50:19 +0000

The phrase "Auth0 post" is often interpreted as either an Auth0 Post-Login Action (a piece of code) or a blog post (content).

Here are prompts for both:

1. Prompt for an Auth0 Post-Login Action (Code)

Goal: Automatic User Profile Enrichment

Scenario: Your application requires certain user metadata (like a custom loyalty_tier or an internal employee_id) to be present in the user's Auth0 profile before they can access a specific area of your app. This data is stored in an external company database.

Prompt:

"Write the JavaScript code for an Auth0 Post-Login Action that performs the following steps:

It checks if the user's current Auth0 profile (user.app_metadata) contains a key called is_data_synced.

If is_data_synced is not present or is false, it makes an asynchronous call (using api.fetch) to a hypothetical external API endpoint (https://api.internal-db.com/user-data?id=${user.user_id}).

Upon receiving a successful response from the external API, it updates the Auth0 user's app_metadata to include the fetched data (e.g., loyalty_tier: 'Gold') and sets is_data_synced to true.

If the external API call fails, the Action should simply log an error but allow the login to proceed.

Provide the complete onExecutePostLogin function."

2. Prompt for an Auth0 Blog Post (Content)

Goal: Generating a technical article.

Prompt:

"Generate a detailed, step-by-step blog post titled: 'The Power of POST: Securely Exchanging the Authorization Code for Tokens in Auth0.'

Your post should cover:

An introduction to why the token exchange must be a POST request (server-side) instead of a GET request.

A clear explanation of the three critical parameters included in the POST request body (grant_type, client_id, client_secret, and code).

The structure of the JSON response returned by the /oauth/token endpoint (focusing on id_token and access_token).

A concise code example (using Python or Node.js) demonstrating the server-side POST request."

https://app-directory-ci8cmyiw9-rushikeshs-projects-fe215f6d.vercel.app/

App

Rushikesh Pundkar — Wed, 08 Oct 2025 14:37:49 +0000

The phrase "Auth0 post" is often interpreted as either an Auth0 Post-Login Action (a piece of code) or a blog post (content).

Here are prompts for both:

1. Prompt for an Auth0 Post-Login Action (Code)

Goal: Automatic User Profile Enrichment

Prompt:

"Write the JavaScript code for an Auth0 Post-Login Action that performs the following steps:

It checks if the user's current Auth0 profile (user.app_metadata) contains a key called is_data_synced.

If is_data_synced is not present or is false, it makes an asynchronous call (using api.fetch) to a hypothetical external API endpoint (https://api.internal-db.com/user-data?id=${user.user_id}).

Upon receiving a successful response from the external API, it updates the Auth0 user's app_metadata to include the fetched data (e.g., loyalty_tier: 'Gold') and sets is_data_synced to true.

If the external API call fails, the Action should simply log an error but allow the login to proceed.

Provide the complete onExecutePostLogin function."

2. Prompt for an Auth0 Blog Post (Content)

Goal: Generating a technical article.

Prompt:

"Generate a detailed, step-by-step blog post titled: 'The Power of POST: Securely Exchanging the Authorization Code for Tokens in Auth0.'

Your post should cover:

An introduction to why the token exchange must be a POST request (server-side) instead of a GET request.

A clear explanation of the three critical parameters included in the POST request body (grant_type, client_id, client_secret, and code).

The structure of the JSON response returned by the /oauth/token endpoint (focusing on id_token and access_token).

A concise code example (using Python or Node.js) demonstrating the server-side POST request."

https://app-directory-ci8cmyiw9-rushikeshs-projects-fe215f6d.vercel.app/

Hacktoberfest challenge prompt

Rushikesh Pundkar — Wed, 01 Oct 2025 10:34:17 +0000

🎃 Hacktoberfest Prompt for story-generator- 📖
Project: Interactive Story Generator
Repository: rushikesh648/story-generator-
https://github.com/rushikesh648/story-generator-
Technology Focus: HTML, CSS, JavaScript (Front-end)

Join us in building a simple, web-based tool that generates short stories based on user input (like names, places, or themes). This project is perfect for beginners looking to make their first contribution!

Beginner-Friendly Contribution Ideas (Pick one!):
Contribution Area Task Description

Documentation (Easy) Create a proper README.md file. Write a clear description of what the Story Generator is, how to run it locally, and what future features are planned.
Core Logic (Intermediate) Implement the basic story generation function in JavaScript. Take input fields (e.g., "A character's name," "A setting") from app.html and use them to construct and display a pre-defined story template.
Styling/UI (Easy) Apply basic CSS to style app.html. Improve the appearance, typography, and layout of the input fields and the story output area. (Consider using a CSS framework like Bootstrap or Tailwind if you know it!)
Contribution Guide (Easy) Add a CONTRIBUTING.md file. Define clear steps for others to fork, clone, and submit Pull Requests to the repository. This is crucial for Hacktoberfest success!
Feature Enhancement (Intermediate) Add form validation to the input fields. Use JavaScript to ensure that all required story prompts are filled out before the "Generate Story" button can be clicked.

Export to Sheets
Remember to tag your Pull Requests with the Hacktoberfest label (if the repository maintainer has set it up) or mention "Ready for Hacktoberfest" in the PR description.

Auth0

Rushikesh Pundkar — Sun, 28 Sep 2025 12:16:38 +0000

https://app-directory-ci8cmyiw9-rushikeshs-projects-fe215f6d.vercel.app/

Packagist

Rushikesh Pundkar — Sat, 27 Sep 2025 06:30:06 +0000

Packagist API

Simple object oriented wrapper for Packagist API.

Requirements

PHP ^7.4 or ^8.0 (for PHP 7.1-7.3 please use the 1.x release line)

Installation

The recommended way to install Packagist API is through composer:

composer require knplabs/packagist-api

Usage

Search for packages:

<?php

$client = new Packagist\Api\Client();

foreach ($client->search('sylius') as $result) {
    echo $result->getName();
}

// Outputs:
sylius/sylius
sylius/resource-bundle
sylius/cart-bundle
sylius/flow-bundle
sylius/sales-bundle
sylius/shipping-bundle
sylius/taxation-bundle
sylius/money-bundle
sylius/assortment-bundle
sylius/addressing-bundle
sylius/payments-bundle
sylius/taxonomies-bundle
sylius/inventory-bundle
sylius/settings-bundle
sylius/promotions-bundle
...

You can limit results to a desired amount of pages:

<?php

$client->search('sylius', [], 2)  // get first 2 pages

Get package details:

Gets full package details, generated dynamically by the Packagist API.
Consider using getComposer()
instead to use the Packagist API more efficiently if you don't need all
the full metadata for a package.

<?php

$package = $client->get('sylius/sylius');

printf(
    'Package %s. %s.',
    $package->getName(),
    $package->getDescription()
);

// Outputs:
Package sylius/sylius. Modern ecommerce for Symfony2.

Get composer details: {#get-composer-details}

Similar to get(), but uses Composer metadata which is Packagist's preferred
way of retrieving details, since responses are cached efficiently as static files
by the Packagist service. The response lacks some metadata that is provided
by get(), see Packagist API documentation
for details. Returns multiple packages, you need to select the requested
one from the indexed array.

<?php

$packages = $client->getComposer('sylius/sylius');
$package = $packages['sylius/sylius'];
$versions = $package->getVersions();

printf(
    'Package %s. %s.',
    $versions[0]->getName(),
    $versions[0]->getDescription()
);

// Outputs:
Package sylius/sylius. Modern ecommerce for Symfony2.

List all packages:

<?php

foreach ($client->all() as $package) {
    echo $package;
}

// Outputs:
abhinavsingh/jaxl
abishekrsrikaanth/fuel-util
abmundi/database-commands-bundle
...

They can be filtered by type or vendor:

<?php

$client->all(array('type' => 'library'));
$client->all(array('vendor' => 'sylius'));

Custom Packagist repositories

You can also set a custom Packagist repository URL:

<?php

$client->setPackagistUrl('https://custom.packagist.site.org');

Errors

A Packagist\Api\PackageNotFoundException will be thrown when the Packagist API returns a 404 response.
An \InvalidArgumentException will be thrown when the response from Packagist was not able to be parsed.

License

packagist-api is licensed under the MIT License - see the LICENSE file for details.

Maintainers

KNPLabs is looking for maintainers (see why).

If you are interested, feel free to open a PR to ask to be added as a maintainer.

We’ll be glad to hear from you :)

This library is maintained by the following people (alphabetically sorted) :

@robbieaverill GitHub link:https://github.com/rushikesh648/packagist-api

Repo

Rushikesh Pundkar — Fri, 26 Sep 2025 16:25:43 +0000

MarkItDown

[!TIP]
MarkItDown now offers an MCP (Model Context Protocol) server for integration with LLM applications like Claude Desktop. See markitdown-mcp for more information.

[!IMPORTANT]
Breaking changes between 0.0.1 to 0.1.0:

Dependencies are now organized into optional feature-groups (further details below). Use pip install 'markitdown[all]' to have backward-compatible behavior.

convert_stream() now requires a binary file-like object (e.g., a file opened in binary mode, or an io.BytesIO object). This is a breaking change from the previous version, where it previously also accepted text file-like objects, like io.StringIO.

The DocumentConverter class interface has changed to read from file-like streams rather than file paths. No temporary files are created anymore. If you are the maintainer of a plugin, or custom DocumentConverter, you likely need to update your code. Otherwise, if only using the MarkItDown class or CLI (as in these examples), you should not need to change anything.

MarkItDown is a lightweight Python utility for converting various files to Markdown for use with LLMs and related text analysis pipelines. To this end, it is most comparable to textract, but with a focus on preserving important document structure and content as Markdown (including: headings, lists, tables, links, etc.) While the output is often reasonably presentable and human-friendly, it is meant to be consumed by text analysis tools -- and may not be the best option for high-fidelity document conversions for human consumption.

MarkItDown currently supports the conversion from:

PDF
PowerPoint
Word
Excel
Images (EXIF metadata and OCR)
Audio (EXIF metadata and speech transcription)
HTML
Text-based formats (CSV, JSON, XML)
ZIP files (iterates over contents)
Youtube URLs
EPubs
... and more!

Why Markdown?

Markdown is extremely close to plain text, with minimal markup or formatting, but still
provides a way to represent important document structure. Mainstream LLMs, such as
OpenAI's GPT-4o, natively "speak" Markdown, and often incorporate Markdown into their
responses unprompted. This suggests that they have been trained on vast amounts of
Markdown-formatted text, and understand it well. As a side benefit, Markdown conventions
are also highly token-efficient.

Prerequisites

MarkItDown requires Python 3.10 or higher. It is recommended to use a virtual environment to avoid dependency conflicts.

With the standard Python installation, you can create and activate a virtual environment using the following commands:

python -m venv .venv
source .venv/bin/activate

If using uv, you can create a virtual environment with:

uv venv --python=3.12 .venv
source .venv/bin/activate
# NOTE: Be sure to use 'uv pip install' rather than just 'pip install' to install packages in this virtual environment

If you are using Anaconda, you can create a virtual environment with:

conda create -n markitdown python=3.12
conda activate markitdown

Installation

To install MarkItDown, use pip: pip install 'markitdown[all]'. Alternatively, you can install it from the source:

git clone git@github.com:microsoft/markitdown.git
cd markitdown
pip install -e 'packages/markitdown[all]'

Usage

Command-Line

markitdown path-to-file.pdf > document.md

Or use -o to specify the output file:

markitdown path-to-file.pdf -o document.md

You can also pipe content:

cat path-to-file.pdf | markitdown

Optional Dependencies

MarkItDown has optional dependencies for activating various file formats. Earlier in this document, we installed all optional dependencies with the [all] option. However, you can also install them individually for more control. For example:

pip install 'markitdown[pdf, docx, pptx]'

will install only the dependencies for PDF, DOCX, and PPTX files.

At the moment, the following optional dependencies are available:

[all] Installs all optional dependencies
[pptx] Installs dependencies for PowerPoint files
[docx] Installs dependencies for Word files
[xlsx] Installs dependencies for Excel files
[xls] Installs dependencies for older Excel files
[pdf] Installs dependencies for PDF files
[outlook] Installs dependencies for Outlook messages
[az-doc-intel] Installs dependencies for Azure Document Intelligence
[audio-transcription] Installs dependencies for audio transcription of wav and mp3 files
[youtube-transcription] Installs dependencies for fetching YouTube video transcription

Plugins

MarkItDown also supports 3rd-party plugins. Plugins are disabled by default. To list installed plugins:

markitdown --list-plugins

To enable plugins use:

markitdown --use-plugins path-to-file.pdf

To find available plugins, search GitHub for the hashtag #markitdown-plugin. To develop a plugin, see packages/markitdown-sample-plugin.

Azure Document Intelligence

To use Microsoft Document Intelligence for conversion:

markitdown path-to-file.pdf -o document.md -d -e "<document_intelligence_endpoint>"

More information about how to set up an Azure Document Intelligence Resource can be found here

Python API

Basic usage in Python:

from markitdown import MarkItDown

md = MarkItDown(enable_plugins=False) # Set to True to enable plugins
result = md.convert("test.xlsx")
print(result.text_content)

Document Intelligence conversion in Python:

from markitdown import MarkItDown

md = MarkItDown(docintel_endpoint="<document_intelligence_endpoint>")
result = md.convert("test.pdf")
print(result.text_content)

To use Large Language Models for image descriptions (currently only for pptx and image files), provide llm_client and llm_model:

from markitdown import MarkItDown
from openai import OpenAI

client = OpenAI()
md = MarkItDown(llm_client=client, llm_model="gpt-4o", llm_prompt="optional custom prompt")
result = md.convert("example.jpg")
print(result.text_content)

Docker

docker build -t markitdown:latest .
docker run --rm -i markitdown:latest < ~/your-file.pdf > output.md

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

When you submit a pull request, a CLA bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct.
For more information see the Code of Conduct FAQ or
contact opencode@microsoft.com with any additional questions or comments.

How to Contribute

You can help by looking at issues or helping review PRs. Any issue or PR is welcome, but we have also marked some as 'open for contribution' and 'open for reviewing' to help facilitate community contributions. These are of course just suggestions and you are welcome to contribute in any way you like.

| | All | Especially Needs Help from Community | | ---------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- | | **Issues** | [All Issues](https://github.com/microsoft/markitdown/issues) | [Issues open for contribution](https://github.com/microsoft/markitdown/issues?q=is%3Aissue+is%3Aopen+label%3A%22open+for+contribution%22) | | **PRs** | [All PRs](https://github.com/microsoft/markitdown/pulls) | [PRs open for reviewing](https://github.com/microsoft/markitdown/pulls?q=is%3Apr+is%3Aopen+label%3A%22open+for+reviewing%22) |

Running Tests and Checks

Navigate to the MarkItDown package:

  cd packages/markitdown

Install hatch in your environment and run tests:

  pip install hatch  # Other ways of installing hatch: https://hatch.pypa.io/dev/install/
  hatch shell
  hatch test

(Alternative) Use the Devcontainer which has all the dependencies installed:

  # Reopen the project in Devcontainer and run:
  hatch test

Run pre-commit checks before submitting a PR: pre-commit run --all-files

Contributing 3rd-party Plugins

You can also contribute by creating and sharing 3rd party plugins. See packages/markitdown-sample-plugin for more details.

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must follow
Microsoft's Trademark & Brand Guidelines.
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.
Within link:
https://github.com/rushikesh648/markitdown

Microsoft Open Source Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct.

Resources:

Microsoft Open Source Code of Conduct
Microsoft Code of Conduct FAQ
Contact opencode@microsoft.com with questions or concerns

Latest health-ui

Rushikesh Pundkar — Sun, 21 Sep 2025 15:07:13 +0000