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