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