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