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