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