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