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