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