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