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