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