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