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