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