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