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