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