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