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