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