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