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