Hello i have this code thats not written out in the write form can someone rearrange it for me quickly Thank you [closed]

.file 1 “” .section .mdebug.abi32 .previous .nan legacy .module fp=32 .module nooddspreg .abicalls .rdata .align 2 LC0: .ascii “Enter number of elements in array0” .align 2LC1: .ascii “%d0” .align 2 LC2: .ascii “Enter %d integers20” .align 2LC3: .ascii “Minimum element is present at location %d and its value ” .ascii “is %d.20” .text .align 2 .globl main .set nomips16 .set nomicromips .ent main .type main, @function main: .frame $$fp,448,$$31 # vars= 416, regs= 2/0, args= 16, gp= 8 .mask 0xc0000000,-4 .fmask 0x00000000,0 .set noreorder .cpload $$25 .set nomacro addiu$$sp,$$sp,-448 sw$$31,444($$sp) sw$$fp,440($$sp) move$$fp,$$sp .cprestore 16 movz$$31,$$31,$$0 li $$2,1 # 0x1 sw$$2,32($$fp) lw$$2,%got($$LC0)($$28) nop addiu $$4,$$2,%lo($$LC0) lw$$2,%call16(puts)($$28) nop move$$25,$$2 .reloc 1f,R_MIPS_JALR,puts 1: jalr$$25 nop lw $$28,16($$fp) addiu $$2,$$fp,436 move $$5,$$2 lw $$2,%got($$LC1)($$28) nop addiu$$4,$$2,%lo($$LC1) lw $$2,%call16(__isoc99_scanf)($$28) nop move $$25,$$2 .reloc 1f,R_MIPS_JALR,__isoc99_scanf 1: jalr $$25 nop lw$$28,16($$fp) lw$$2,436($$fp) nop move$$5,$$2 lw$$2,%got($$LC2)($$28) nop addiu $$4,$$2,%lo($$LC2) lw$$2,%call16(printf)($$28) nop move$$25,$$2 .reloc 1f,R_MIPS_JALR,printf 1: jalr$$25 nop lw $$28,16($$fp) sw $$0,28($$fp) b $$L2 nop$$L3: addiu $$3,$$fp,36 lw $$2,28($$fp) nop sll $$2,$$2,2 addu $$2,$$3,$$2 move$$5,$$2 lw$$2,%got($$LC1)($$28) nop addiu $$4,$$2,%lo($$LC1) lw$$2,%call16(__isoc99_scanf)($$28) nop move$$25,$$2 .reloc 1f,R_MIPS_JALR,__isoc99_scanf 1: jalr$$25 nop lw $$28,16($$fp) lw $$2,28($$fp) nop addiu $$2,$$2,1 sw $$2,28($$fp) $$L2: lw$$2,436($$fp) lw$$3,28($$fp) nop slt$$2,$$3,$$2 bne $$2,$$0,$$L3 nop lw$$2,36($$fp) nop sw$$2,24($$fp) li$$2,1 # 0x1 sw $$2,28($$fp) b $$L4 nop$$L6: lw $$2,28($$fp) nop sll $$2,$$2,2 addiu $$3,$$fp,24 addu $$2,$$3,$$2 lw$$3,12($$2) lw$$2,24($$fp) nop slt$$2,$$3,$$2 beq $$2,$$0,$$L5 nop lw$$2,28($$fp) nop sll$$2,$$2,2 addiu$$3,$$fp,24 addu$$2,$$3,$$2 lw $$2,12($$2) nop sw $$2,24($$fp) lw $$2,28($$fp) nop addiu $$2,$$2,1 sw $$2,32($$fp) $$L5: lw$$2,28($$fp) nop addiu$$2,$$2,1 sw$$2,28($$fp)$$L4: lw $$2,436($$fp) lw $$3,28($$fp) nop slt $$2,$$3,$$2 bne$$2,$$0,$$L6 nop lw $$6,24($$fp) lw $$5,32($$fp) lw $$2,%got($$LC3)($$28) nop addiu$$4,$$2,%lo($$LC3) lw $$2,%call16(printf)($$28) nop move $$25,$$2 .reloc 1f,R_MIPS_JALR,printf 1: jalr $$25 nop lw$$28,16($$fp) move$$2,$$0 move$$sp,$$fp lw$$31,444($$sp) lw$$fp,440($$sp) addiu$$sp,$$sp,448 j$$31 nop .set macro .set reorder .end main .size main, .-main .ident “GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609”

Are there any canon examples of texts written in elvish?

I’m referring to the Elven language of the Forgotten Realms, usually written with the Espruar script. Are there any examples of messages, poems, paragraphs, …? More specifically, ones that make sense in the language, not just random letters from the Espruar script.

Entrypoint on webapp allows semi-arbitrary data to be written. Can it be considered as DoS?

Me and my team have written a web app, and we had a bug report regarding a DoS vulnerability.

This vulnerability, requires a basic account to be created and allows this user to inject semi-arbitrary data “mydata-XXX-mydata” where “XXX” is controlled by the attacker. This data is not supposed to be controlled by the user and allows DB inserts, as many as the user requests them. The reported bug uses a bypass technic to allow this data to be altered.

We do believe that it could slow down/fill up the DB (and probably disk space). Can it be considered as a DoS vulnerability and worth reporting a CVE for that?

Thank you

Why is the complexity of BFS & DFS frequently written as O(V+E) vs. O(max(V,E))

Why is the complexity of BFS & DFS frequently written as O(V+E) vs. O(max(V,E)) when the 2 are equivalent?

I feel like the latter conveys more meaning and is more simplified, and we can more easily see that the time grows as a function of the number of vertices OR edges, whichever is greater, whereas the latter reads “the time grows as a function of the number of vertices AND edges”

What would a Warlock understand from written spells outside of their class, via Eyes of the Rune Keeper?

This related question asks if you could transcribe a ritual spell to the warlock book via the Book of Ancient Secrets invocation regardless of spell lists, and the answers were generally “yes, but you can’t tell what the spell is”.

This other one asks if you had the Eyes of the Rune Keeper invocation, “could you cast a scroll of a spell outside of your spell list?”, and the answer, using a quote from Crawford, was that you cannot cast the spell since it was out of your spell list (but it did not state if you could actually read the scroll).

By this point, you can probably guess where I’m getting at.

The description of the Warlock eldritch invocation, Eyes of the Rune Keeper:

You can read all writing. You can comprehend any written word or symbol, should it hold any linguistic meaning.

The rules on scrolls outside of your spell list:

If the spell is on your class’s spell list, you can read the scroll and cast its spell without providing any material Components. Otherwise, the scroll is unintelligible.

Can I understand magical literature that is normally outside of my class list if I have the Eyes of the Rune Keeper?

What would I be able to identify from a written spell with Eyes of the Rune Keeper?

Note: I am not asking if I can cast spells outside of my class with the invocation; I am asking if I can understand the nature of the scroll/spell, even if I can’t cast from it.

Related: Can Warlock's Eyes of the Rune Keeper decipher written code?

What is the run time of this algorithm, written in pseudocode?

count = 0 for i = 1 to n:     for j = 1 to i:         count += 1 

So from my understanding, we can break this up into 2 summations, by nesting the $$j$$ loop as a summation into the $$i$$ loop as a summation as follows:

$$\sum\limits_{i=1}^{n} \sum\limits_{j=1}^{i}$$1

Since incrementing count is 1 operation O(1).

Then, we can manipulate the above summation to:

= $$\sum\limits_{i=1}^{n} (i – 1 + 1)$$ using property of summations

= $$\sum\limits_{i=1}^{n} i$$

= $$\frac{n(n+1)}{2}$$ = $$O(n^2)$$

Is this the correct approach?

In which paper is written that you can transform one problem to another to show NP-completeness?

For example in this post they discuss how to construct a reduction between problems to show that one probleme is NP-Hard: Post

I am searching for a scientific paper to cite where it is written, that this is a valid method.

Does anybody knows one?

In what ways can the contents of RAM be (inadvertently) written to disk?

I’m working on improving the security of my own system by mitigating the chance sensitive information, (e.g. encryption keys) stored in RAM, are inadvertently written to disk. As of now I know of three common ways this can occur and how they could be mitigated:

1. The contents of RAM are copied to hiberfil.sys when Windows Hibernates
• Solution: Disable Windows Hibernation
2. Some contents of RAM are copied into the swap file.
• Solution: Encrypt the swap file.
3. Memory Dumps during Windows Blue-screens.
• Solution: Disable memory dump file generation

Excluding these (as well as tools specifically designed to dump memory) are there any other reasons RAM could unintentionally be written to disk by the operating system?

I would really appreciate any help I could get!

Number of ways n can be written as sum of at least two positive integers

I found a solution in Python for this problem, but do not understand it. The problem is how many ways an integer n can be written as the sum of at least two positive integers. For example, take n = 5. The number 5 can be written as

4 + 1 3 + 2 3 + 1 + 1 2 + 2 + 1 2 + 1 + 1 + 1 1 + 1 + 1 + 1 + 1 

Here’s a solution for n = 100.

n = 100 ways = [1] + [0]*n  for i in range(1, n):     for j in range(i, n+1):         ways[j] += ways[j-i]  print ways[n] 

This solution is elegant and efficient, but unfortunately, I do not understand the logic. Can someone please explain the logic of this solution to the problem? Is there a way to make this algorithm easy to understand?

Can full first order knowledge base be written as the single sequent in the sequent calculus?

The knowledge base of the first order logic essentially is single formula: conjunction of individual formulas (I guess, I am right). The sequent for the sequent calculus is the formula in the special form – it is implication with the conjunction on the left hand side and the disjunction on the right hand side. Turnstile symbol and commas can be used to write down this special knid of formula. I have heard, that every FOL formula can be rewritten as the sequent, am I right. Then one can conclude that every knowlege base can be written as the single sequent. And every reasoning over this knowledge base can be expressed as the application of the sequent rules (in top-down or bottom-up direction). Am I right?

Am I right about this format? And why the sequent calculus are not used wider in the practical applications, implementations of the knowledge bases?