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