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