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