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