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