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