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