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