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