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